LLVMFuzzerTestOneInput: 36| 1.51k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 37| 1.51k| char *new_str = (char *)malloc(size + 1); 38| 1.51k| if (new_str == NULL) { ------------------ | Branch (38:7): [True: 0, False: 1.51k] ------------------ 39| 0| return 0; 40| 0| } 41| 1.51k| memcpy(new_str, data, size); 42| 1.51k| new_str[size] = '\0'; 43| | 44| 1.51k| apr_pool_initialize(); 45| 1.51k| apr_pool_t *v = NULL; 46| 1.51k| apr_pool_create(&v, NULL); ------------------ | | 301| 1.51k| apr_pool_create_ex(newpool, parent, NULL, NULL) ------------------ 47| | 48| 1.51k| int only_ascii = 1; 49| 22.5M| for (int i = 0; i < size; i++) { ------------------ | Branch (49:19): [True: 22.5M, False: 1.51k] ------------------ 50| | // Avoid unnessary exits because of non-ascii characters. 51| 22.5M| if (new_str[i] < 0x01 || new_str[i] > 0x7f) { ------------------ | Branch (51:9): [True: 1.60M, False: 20.9M] | Branch (51:30): [True: 0, False: 20.9M] ------------------ 52| 1.60M| only_ascii = 0; 53| 1.60M| } 54| | // Avoid forced exits beause of, e.g. unsupported characters or recursion 55| | // depth 56| 22.5M| if (new_str[i] == 0x5c || new_str[i] == '{') { ------------------ | Branch (56:9): [True: 195, False: 22.5M] | Branch (56:31): [True: 195, False: 22.5M] ------------------ 57| 390| only_ascii = 0; 58| 390| } 59| 22.5M| } 60| | 61| | // Now parse 62| 1.51k| if (only_ascii) { ------------------ | Branch (62:7): [True: 1.48k, False: 33] ------------------ 63| 1.48k| ap_expr_info_t val; 64| 1.48k| ap_expr_parse(v, v, &val, new_str, NULL); 65| 1.48k| } 66| | 67| 1.51k| apr_pool_terminate(); 68| 1.51k| free(new_str); 69| 1.51k| return 0; 70| 1.51k|} ap_pregcomp: 266| 5.76k|{ 267| 5.76k| ap_regex_t *preg = apr_palloc(p, sizeof *preg); ------------------ | | 425| 5.76k| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | ------------------ | | | | 143| 5.76k|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 160| 5.76k|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 162| 5.76k|#define APR_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 268| 5.76k| int err = ap_regcomp(preg, pattern, cflags); 269| 5.76k| if (err) { ------------------ | Branch (269:9): [True: 0, False: 5.76k] ------------------ 270| 0| if (err == AP_REG_ESPACE) ------------------ | Branch (270:13): [True: 0, False: 0] ------------------ 271| 0| ap_abort_on_oom(); 272| 0| return NULL; 273| 0| } 274| | 275| 5.76k| apr_pool_cleanup_register(p, (void *) preg, regex_cleanup, 276| 5.76k| apr_pool_cleanup_null); 277| | 278| 5.76k| return preg; 279| 5.76k|} util.c:regex_cleanup: 259| 5.76k|{ 260| 5.76k| ap_regfree((ap_regex_t *) preg); 261| 5.76k| return APR_SUCCESS; ------------------ | | 225| 5.76k|#define APR_SUCCESS 0 ------------------ 262| 5.76k|} ap_expr_lookup_default: 574| 2.03k|{ 575| 2.03k| return ap_run_expr_lookup(parms); 576| 2.03k|} ap_expr_parse: 581| 1.48k|{ 582| 1.48k| ap_expr_parse_ctx_t ctx; 583| 1.48k| int rc; 584| | 585| 1.48k| memset(&ctx, 0, sizeof ctx); 586| 1.48k| ctx.pool = pool; 587| 1.48k| ctx.ptemp = ptemp; 588| 1.48k| ctx.inputbuf = expr; 589| 1.48k| ctx.inputlen = strlen(expr); 590| 1.48k| ctx.inputptr = ctx.inputbuf; 591| 1.48k| ctx.flags = info->flags; 592| 1.48k| ctx.lookup_fn = lookup_fn ? lookup_fn : ap_expr_lookup_default; ------------------ | Branch (592:23): [True: 0, False: 1.48k] ------------------ 593| 1.48k| ctx.at_start = 1; 594| | 595| 1.48k| rc = ap_expr_yylex_init(&ctx.scanner); 596| 1.48k| if (rc) ------------------ | Branch (596:9): [True: 0, False: 1.48k] ------------------ 597| 0| return "ap_expr_yylex_init error"; 598| | 599| 1.48k| ap_expr_yyset_extra(&ctx, ctx.scanner); 600| 1.48k| rc = ap_expr_yyparse(&ctx); 601| 1.48k| ap_expr_yylex_destroy(ctx.scanner); 602| | 603| | /* ctx.error: the generic bison error message 604| | * (XXX: usually not very useful, should be axed) 605| | * ctx.error2: an additional error message 606| | */ 607| 1.48k| if (ctx.error) { ------------------ | Branch (607:9): [True: 174, False: 1.31k] ------------------ 608| 174| if (ctx.error2) ------------------ | Branch (608:13): [True: 32, False: 142] ------------------ 609| 32| return apr_psprintf(pool, "%s: %s", ctx.error, ctx.error2); 610| 142| else 611| 142| return ctx.error; 612| 174| } 613| 1.31k| else if (ctx.error2) { ------------------ | Branch (613:14): [True: 70, False: 1.24k] ------------------ 614| 70| return ctx.error2; 615| 70| } 616| | 617| 1.24k| if (rc) /* XXX can this happen? */ ------------------ | Branch (617:9): [True: 0, False: 1.24k] ------------------ 618| 0| return "syntax error"; 619| | 620| |#ifdef AP_EXPR_DEBUG 621| | if (ctx.expr) 622| | expr_dump_tree(ctx.expr, NULL, APLOG_NOTICE, 2); 623| |#endif 624| | 625| 1.24k| info->root_node = ctx.expr; 626| | 627| 1.24k| return NULL; 628| 1.24k|} ap_expr_make: 652| 65.8k|{ 653| 65.8k| ap_expr_t *node = apr_palloc(ctx->pool, sizeof(ap_expr_t)); ------------------ | | 425| 65.8k| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | ------------------ | | | | 143| 65.8k|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 160| 65.8k|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 162| 65.8k|#define APR_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 654| 65.8k| node->node_op = op; 655| 65.8k| node->node_arg1 = a1; 656| 65.8k| node->node_arg2 = a2; 657| 65.8k| return node; 658| 65.8k|} ap_expr_concat_make: 662| 21.6k|{ 663| 21.6k| const ap_expr_t *node; 664| | 665| | /* Optimize out empty string(s) concatenation */ 666| 21.6k| if ((node = a1) ------------------ | Branch (666:9): [True: 21.6k, False: 0] ------------------ 667| 21.6k| && node->node_op == op_String ------------------ | Branch (667:16): [True: 414, False: 21.2k] ------------------ 668| 21.6k| && !*(const char *)node->node_arg1) { ------------------ | Branch (668:16): [True: 0, False: 414] ------------------ 669| 0| return (ap_expr_t *)a2; 670| 0| } 671| 21.6k| if ((node = a2) ------------------ | Branch (671:9): [True: 21.6k, False: 0] ------------------ 672| 21.6k| && node->node_op == op_String ------------------ | Branch (672:16): [True: 10.7k, False: 10.9k] ------------------ 673| 21.6k| && !*(const char *)node->node_arg1) { ------------------ | Branch (673:16): [True: 219, False: 10.4k] ------------------ 674| 219| return (ap_expr_t *)a1; 675| 219| } 676| | 677| 21.4k| return ap_expr_make(op_Concat, a1, a2, ctx); 678| 21.6k|} ap_expr_regex_make: 682| 5.76k|{ 683| 5.76k| ap_expr_t *node = NULL; 684| 5.76k| ap_expr_regctx_t *regctx; 685| 5.76k| ap_regex_t *regex; 686| | 687| 5.76k| regctx = apr_pcalloc(ctx->pool, sizeof *regctx); ------------------ | | 454| 5.76k| apr_pcalloc_debug(p, size, APR_POOL__FILE_LINE__) | | ------------------ | | | | 143| 5.76k|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 160| 5.76k|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 162| 5.76k|#define APR_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 688| 5.76k| regctx->subst = subst; 689| 5.76k| if (flags) { ------------------ | Branch (689:9): [True: 5.76k, False: 0] ------------------ 690| 6.54k| for (; *flags; ++flags) { ------------------ | Branch (690:16): [True: 781, False: 5.76k] ------------------ 691| 781| switch (*flags) { ------------------ | Branch (691:21): [True: 0, False: 781] ------------------ 692| 6| case 'i': ------------------ | Branch (692:13): [True: 6, False: 775] ------------------ 693| 6| regctx->flags |= AP_REG_ICASE; ------------------ | | 73| 6|#define AP_REG_ICASE 0x01 /**< use a case-insensitive match */ ------------------ 694| 6| break; 695| 164| case 'm': ------------------ | Branch (695:13): [True: 164, False: 617] ------------------ 696| 164| regctx->flags |= AP_REG_NEWLINE; ------------------ | | 74| 164|#define AP_REG_NEWLINE 0x02 /**< don't match newlines against '.' etc */ ------------------ 697| 164| break; 698| 289| case 's': ------------------ | Branch (698:13): [True: 289, False: 492] ------------------ 699| 289| regctx->flags |= AP_REG_DOTALL; ------------------ | | 83| 289|#define AP_REG_DOTALL 0x40 /**< perl's /s flag */ ------------------ 700| 289| break; 701| 322| case 'g': ------------------ | Branch (701:13): [True: 322, False: 459] ------------------ 702| 322| regctx->flags |= AP_REG_MULTI; ------------------ | | 81| 322|#define AP_REG_MULTI 0x10 /**< perl's /g (needs fixing) */ ------------------ 703| 322| break; 704| 781| } 705| 781| } 706| 5.76k| } 707| 5.76k| regex = ap_pregcomp(ctx->pool, pattern, regctx->flags); 708| 5.76k| if (!regex) { ------------------ | Branch (708:9): [True: 0, False: 5.76k] ------------------ 709| 0| return NULL; 710| 0| } 711| | 712| 5.76k| node = apr_palloc(ctx->pool, sizeof(ap_expr_t)); ------------------ | | 425| 5.76k| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | ------------------ | | | | 143| 5.76k|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 160| 5.76k|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 162| 5.76k|#define APR_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 713| 5.76k| node->node_op = op_Regex; 714| 5.76k| node->node_arg1 = regex; 715| 5.76k| node->node_arg2 = regctx; 716| 5.76k| return node; 717| 5.76k|} ap_expr_str_func_make: 761| 525|{ 762| 525| ap_expr_t *info = ap_expr_info_make(AP_EXPR_FUNC_STRING, name, ctx, arg); ------------------ | | 269| 525|#define AP_EXPR_FUNC_STRING 1 ------------------ 763| 525| if (!info) ------------------ | Branch (763:9): [True: 525, False: 0] ------------------ 764| 525| return NULL; 765| | 766| 0| info->node_op = op_StringFuncInfo; 767| 0| return ap_expr_make(op_StringFuncCall, info, arg, ctx); 768| 525|} ap_expr_list_func_make: 772| 932|{ 773| 932| ap_expr_t *info = ap_expr_info_make(AP_EXPR_FUNC_LIST, name, ctx, arg); ------------------ | | 270| 932|#define AP_EXPR_FUNC_LIST 2 ------------------ 774| 932| if (!info) ------------------ | Branch (774:9): [True: 932, False: 0] ------------------ 775| 932| return NULL; 776| | 777| 0| info->node_op = op_ListFuncInfo; 778| 0| return ap_expr_make(op_ListFuncCall, info, arg, ctx); 779| 932|} ap_expr_unary_op_make: 783| 292|{ 784| 292| ap_expr_t *info = ap_expr_info_make(AP_EXPR_FUNC_OP_UNARY, name, ctx, arg); ------------------ | | 271| 292|#define AP_EXPR_FUNC_OP_UNARY 3 ------------------ 785| 292| if (!info) ------------------ | Branch (785:9): [True: 292, False: 0] ------------------ 786| 292| return NULL; 787| | 788| 0| info->node_op = op_UnaryOpInfo; 789| 0| return ap_expr_make(op_UnaryOpCall, info, arg, ctx); 790| 292|} ap_expr_binary_op_make: 794| 286|{ 795| 286| ap_expr_t *args; 796| 286| ap_expr_t *info = ap_expr_info_make(AP_EXPR_FUNC_OP_BINARY, name, ctx, ------------------ | | 272| 286|#define AP_EXPR_FUNC_OP_BINARY 4 ------------------ 797| 286| arg2); 798| 286| if (!info) ------------------ | Branch (798:9): [True: 286, False: 0] ------------------ 799| 286| return NULL; 800| | 801| 0| info->node_op = op_BinaryOpInfo; 802| 0| args = ap_expr_make(op_BinaryOpArgs, arg1, arg2, ctx); 803| 0| return ap_expr_make(op_BinaryOpCall, info, args, ctx); 804| 286|} ap_expr_backref_make: 818| 11.0k|{ 819| 11.0k| int *n = apr_pmemdup(ctx->pool, &num, sizeof(num)); 820| 11.0k| return ap_expr_make(op_Backref, n, NULL, ctx); 821| 11.0k|} util_expr_eval.c:ap_expr_info_make: 722| 2.03k|{ 723| 2.03k| ap_expr_t *info = apr_palloc(ctx->pool, sizeof(ap_expr_t)); ------------------ | | 425| 2.03k| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | ------------------ | | | | 143| 2.03k|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 160| 2.03k|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 162| 2.03k|#define APR_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 724| 2.03k| ap_expr_lookup_parms parms; 725| 2.03k| parms.type = type; 726| 2.03k| parms.flags = ctx->flags; 727| 2.03k| parms.pool = ctx->pool; 728| 2.03k| parms.ptemp = ctx->ptemp; 729| 2.03k| parms.name = name; 730| 2.03k| parms.func = &info->node_arg1; 731| 2.03k| parms.data = &info->node_arg2; 732| 2.03k| parms.err = &ctx->error2; 733| 2.03k| parms.arg = NULL; 734| 2.03k| if (arg) { ------------------ | Branch (734:9): [True: 1.54k, False: 489] ------------------ 735| 1.54k| switch(arg->node_op) { 736| 163| case op_String: ------------------ | Branch (736:13): [True: 163, False: 1.38k] ------------------ 737| 163| parms.arg = arg->node_arg1; 738| 163| break; 739| 21| case op_ListElement: ------------------ | Branch (739:13): [True: 21, False: 1.52k] ------------------ 740| | /* save the first literal/simple string argument */ 741| 28| do { 742| 28| const ap_expr_t *val = arg->node_arg1; 743| 28| if (val && val->node_op == op_String) { ------------------ | Branch (743:25): [True: 17, False: 11] | Branch (743:32): [True: 14, False: 3] ------------------ 744| 14| parms.arg = val->node_arg1; 745| 14| break; 746| 14| } 747| 14| arg = arg->node_arg2; 748| 14| } while (arg != NULL); ------------------ | Branch (748:26): [True: 7, False: 7] ------------------ 749| 0| break; 750| 1.36k| default: ------------------ | Branch (750:13): [True: 1.36k, False: 184] ------------------ 751| 1.36k| break; 752| 1.54k| } 753| 1.54k| } 754| 2.03k| if (ctx->lookup_fn(&parms) != OK) ------------------ | | 461| 2.03k|#define OK 0 /**< Module has handled this stage. */ ------------------ | Branch (754:9): [True: 2.03k, False: 0] ------------------ 755| 2.03k| return NULL; 756| 0| return info; 757| 2.03k|} ap_expr_yyparse: 1165| 1.48k|{ 1166| |/* The lookahead symbol. */ 1167| 1.48k|int yychar; 1168| | 1169| | 1170| |/* The semantic value of the lookahead symbol. */ 1171| |/* Default value used for initialization, for pacifying older GCCs 1172| | or non-GCC compilers. */ 1173| 1.48k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 290| 1.48k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1174| 1.48k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 290| 1.48k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1175| | 1176| | /* Number of syntax errors so far. */ 1177| 1.48k| int yynerrs; 1178| | 1179| 1.48k| int yystate; 1180| | /* Number of tokens to shift before error messages enabled. */ 1181| 1.48k| int yyerrstatus; 1182| | 1183| | /* The stacks and their tools: 1184| | 'yyss': related to states. 1185| | 'yyvs': related to semantic values. 1186| | 1187| | Refer to the stacks through separate pointers, to allow yyoverflow 1188| | to reallocate them elsewhere. */ 1189| | 1190| | /* The state stack. */ 1191| 1.48k| yytype_int16 yyssa[YYINITDEPTH]; 1192| 1.48k| yytype_int16 *yyss; 1193| 1.48k| yytype_int16 *yyssp; 1194| | 1195| | /* The semantic value stack. */ 1196| 1.48k| YYSTYPE yyvsa[YYINITDEPTH]; 1197| 1.48k| YYSTYPE *yyvs; 1198| 1.48k| YYSTYPE *yyvsp; 1199| | 1200| 1.48k| YYSIZE_T yystacksize; ------------------ | | 222| 1.48k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 1201| | 1202| 1.48k| int yyn; 1203| 1.48k| int yyresult; 1204| | /* Lookahead token as an internal (translated) token number. */ 1205| 1.48k| int yytoken = 0; 1206| | /* The variables used to return semantic value and location from the 1207| | action routines. */ 1208| 1.48k| YYSTYPE yyval; 1209| | 1210| 1.48k|#if YYERROR_VERBOSE 1211| | /* Buffer for error messages, and its allocated size. */ 1212| 1.48k| char yymsgbuf[128]; 1213| 1.48k| char *yymsg = yymsgbuf; 1214| 1.48k| YYSIZE_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 222| 1.48k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 1215| 1.48k|#endif 1216| | 1217| 1.48k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1218| | 1219| | /* The number of symbols on the RHS of the reduced rule. 1220| | Keep to zero when no symbol should be popped. */ 1221| 1.48k| int yylen = 0; 1222| | 1223| 1.48k| yyssp = yyss = yyssa; 1224| 1.48k| yyvsp = yyvs = yyvsa; 1225| 1.48k| yystacksize = YYINITDEPTH; ------------------ | | 900| 1.48k|# define YYINITDEPTH 200 ------------------ 1226| | 1227| 1.48k| YYDPRINTF ((stderr, "Starting parse\n")); 1228| | 1229| 1.48k| yystate = 0; 1230| 1.48k| yyerrstatus = 0; 1231| 1.48k| yynerrs = 0; ------------------ | | 67| 1.48k|#define yynerrs ap_expr_yynerrs ------------------ 1232| 1.48k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 734| 1.48k|#define YYEMPTY (-2) ------------------ 1233| 1.48k| goto yysetstate; 1234| | 1235| | /* TODO: compiler warning that this is unused, and it seems to */ 1236| 0| (void)yynerrs; ------------------ | | 67| 0|#define yynerrs ap_expr_yynerrs ------------------ 1237| |/*------------------------------------------------------------. 1238| || yynewstate -- Push a new state, which is found in yystate. | 1239| |`------------------------------------------------------------*/ 1240| 238k| yynewstate: 1241| | /* In all cases, when you get here, the value and location stacks 1242| | have just been pushed. So pushing a state here evens the stacks. */ 1243| 238k| yyssp++; 1244| | 1245| 239k| yysetstate: 1246| 239k| *yyssp = yystate; 1247| | 1248| 239k| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1248:7): [True: 114, False: 239k] ------------------ 1249| 114| { 1250| | /* Get the current used size of the three stacks, in elements. */ 1251| 114| YYSIZE_T yysize = yyssp - yyss + 1; ------------------ | | 222| 114|# define YYSIZE_T __SIZE_TYPE__ ------------------ 1252| | 1253| |#ifdef yyoverflow 1254| | { 1255| | /* Give user a chance to reallocate the stack. Use copies of 1256| | these so that the &'s don't force the real ones into 1257| | memory. */ 1258| | YYSTYPE *yyvs1 = yyvs; 1259| | yytype_int16 *yyss1 = yyss; 1260| | 1261| | /* Each stack pointer address is followed by the size of the 1262| | data in use in that stack, in bytes. This used to be a 1263| | conditional around just the two extra args, but that might 1264| | be undefined if yyoverflow is a macro. */ 1265| | yyoverflow (YY_("memory exhausted"), 1266| | &yyss1, yysize * sizeof (*yyssp), 1267| | &yyvs1, yysize * sizeof (*yyvsp), 1268| | &yystacksize); 1269| | 1270| | yyss = yyss1; 1271| | yyvs = yyvs1; 1272| | } 1273| |#else /* no yyoverflow */ 1274| |# ifndef YYSTACK_RELOCATE 1275| | goto yyexhaustedlab; 1276| |# else 1277| | /* Extend the stack our own way. */ 1278| 114| if (YYMAXDEPTH <= yystacksize) ------------------ | | 911| 114|# define YYMAXDEPTH 10000 ------------------ | Branch (1278:11): [True: 2, False: 112] ------------------ 1279| 2| goto yyexhaustedlab; 1280| 112| yystacksize *= 2; 1281| 112| if (YYMAXDEPTH < yystacksize) ------------------ | | 911| 112|# define YYMAXDEPTH 10000 ------------------ | Branch (1281:11): [True: 3, False: 109] ------------------ 1282| 3| yystacksize = YYMAXDEPTH; ------------------ | | 911| 3|# define YYMAXDEPTH 10000 ------------------ 1283| | 1284| 112| { 1285| 112| yytype_int16 *yyss1 = yyss; 1286| 112| union yyalloc *yyptr = 1287| 112| (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); ------------------ | | 340| 112|# define YYSTACK_ALLOC YYMALLOC | | ------------------ | | | | 354| 112|# define YYMALLOC malloc | | ------------------ ------------------ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); ------------------ | | 386| 112| ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ | | 387| 112| + YYSTACK_GAP_MAXIMUM) | | ------------------ | | | | 381| 112|# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) | | ------------------ ------------------ 1288| 112| if (! yyptr) ------------------ | Branch (1288:13): [True: 0, False: 112] ------------------ 1289| 0| goto yyexhaustedlab; 1290| 112| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 397| 112| do \ | | 398| 112| { \ | | 399| 112| YYSIZE_T yynewbytes; \ | | ------------------ | | | | 222| 112|# define YYSIZE_T __SIZE_TYPE__ | | ------------------ | | 400| 112| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 415| 112| __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) | | ------------------ | | 401| 112| Stack = &yyptr->Stack_alloc; \ | | 402| 112| yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 381| 112|# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) | | ------------------ | | 403| 112| yyptr += yynewbytes / sizeof (*yyptr); \ | | 404| 112| } \ | | 405| 112| while (0) | | ------------------ | | | Branch (405:12): [Folded - Ignored] | | ------------------ ------------------ 1291| 112| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 397| 112| do \ | | 398| 112| { \ | | 399| 112| YYSIZE_T yynewbytes; \ | | ------------------ | | | | 222| 112|# define YYSIZE_T __SIZE_TYPE__ | | ------------------ | | 400| 112| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 415| 112| __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) | | ------------------ | | 401| 112| Stack = &yyptr->Stack_alloc; \ | | 402| 112| yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 381| 112|# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) | | ------------------ | | 403| 112| yyptr += yynewbytes / sizeof (*yyptr); \ | | 404| 112| } \ | | 405| 112| while (0) | | ------------------ | | | Branch (405:12): [Folded - Ignored] | | ------------------ ------------------ 1292| 112|# undef YYSTACK_RELOCATE 1293| 112| if (yyss1 != yyssa) ------------------ | Branch (1293:13): [True: 70, False: 42] ------------------ 1294| 70| YYSTACK_FREE (yyss1); ------------------ | | 341| 70|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 360| 70|# define YYFREE free | | ------------------ ------------------ 1295| 112| } 1296| 0|# endif 1297| 0|#endif /* no yyoverflow */ 1298| | 1299| 0| yyssp = yyss + yysize - 1; 1300| 112| yyvsp = yyvs + yysize - 1; 1301| | 1302| 112| YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1303| 112| (unsigned long int) yystacksize)); 1304| | 1305| 112| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1305:11): [True: 0, False: 112] ------------------ 1306| 0| YYABORT; ------------------ | | 738| 0|#define YYABORT goto yyabortlab ------------------ 1307| 112| } 1308| | 1309| 239k| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1310| | 1311| 239k| if (yystate == YYFINAL) ------------------ | | 430| 239k|#define YYFINAL 31 ------------------ | Branch (1311:7): [True: 1.24k, False: 238k] ------------------ 1312| 1.24k| YYACCEPT; ------------------ | | 737| 1.24k|#define YYACCEPT goto yyacceptlab ------------------ 1313| | 1314| 238k| goto yybackup; 1315| | 1316| |/*-----------. 1317| || yybackup. | 1318| |`-----------*/ 1319| 238k|yybackup: 1320| | 1321| | /* Do appropriate processing given the current state. Read a 1322| | lookahead token if we need one and don't already have one. */ 1323| | 1324| | /* First try to decide what to do without reference to lookahead token. */ 1325| 238k| yyn = yypact[yystate]; 1326| 238k| if (yypact_value_is_default (yyn)) ------------------ | | 550| 238k| (!!((Yystate) == (-38))) | | ------------------ | | | Branch (550:3): [True: 95.1k, False: 143k] | | ------------------ ------------------ 1327| 95.1k| goto yydefault; 1328| | 1329| | /* Not known => get a lookahead token if don't already have one. */ 1330| | 1331| | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1332| 143k| if (yychar == YYEMPTY) ------------------ | | 734| 143k|#define YYEMPTY (-2) ------------------ | Branch (1332:7): [True: 138k, False: 4.68k] ------------------ 1333| 138k| { 1334| 138k| YYDPRINTF ((stderr, "Reading a token: ")); 1335| 138k| yychar = yylex (&yylval, yyscanner); ------------------ | | 64| 138k|#define yylex ap_expr_yylex ------------------ yychar = yylex (&yylval, yyscanner); ------------------ | | 186| 138k|#define yyscanner ctx->scanner ------------------ 1336| 138k| } 1337| | 1338| 143k| if (yychar <= YYEOF) ------------------ | | 735| 143k|#define YYEOF 0 ------------------ | Branch (1338:7): [True: 3.23k, False: 140k] ------------------ 1339| 3.23k| { 1340| 3.23k| yychar = yytoken = YYEOF; ------------------ | | 735| 3.23k|#define YYEOF 0 ------------------ 1341| 3.23k| YYDPRINTF ((stderr, "Now at end of input.\n")); 1342| 3.23k| } 1343| 140k| else 1344| 140k| { 1345| 140k| yytoken = YYTRANSLATE (yychar); ------------------ | | 449| 140k| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 446| 140k|#define YYMAXUTOK 301 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 445| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (449:4): [True: 140k, False: 0] | | ------------------ ------------------ 1346| 140k| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1347| 140k| } 1348| | 1349| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1350| | detect an error, take that action. */ 1351| 143k| yyn += yytoken; 1352| 143k| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 432| 143k|#define YYLAST 274 ------------------ | Branch (1352:7): [True: 99, False: 143k] | Branch (1352:18): [True: 0, False: 143k] | Branch (1352:34): [True: 4.75k, False: 138k] ------------------ 1353| 4.85k| goto yydefault; 1354| 138k| yyn = yytable[yyn]; 1355| 138k| if (yyn <= 0) ------------------ | Branch (1355:7): [True: 0, False: 138k] ------------------ 1356| 0| { 1357| 0| if (yytable_value_is_error (yyn)) ------------------ | | 555| 0| 0 | | ------------------ | | | Branch (555:3): [Folded - Ignored] | | ------------------ ------------------ 1358| 0| goto yyerrlab; 1359| 0| yyn = -yyn; 1360| 0| goto yyreduce; 1361| 0| } 1362| | 1363| | /* Count tokens shifted since error; after three, turn off error 1364| | status. */ 1365| 138k| if (yyerrstatus) ------------------ | Branch (1365:7): [True: 0, False: 138k] ------------------ 1366| 0| yyerrstatus--; 1367| | 1368| | /* Shift the lookahead token. */ 1369| 138k| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1370| | 1371| | /* Discard the shifted token. */ 1372| 138k| yychar = YYEMPTY; ------------------ | | 734| 138k|#define YYEMPTY (-2) ------------------ 1373| | 1374| 138k| yystate = yyn; 1375| 138k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1376| 138k| *++yyvsp = yylval; 1377| 138k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1378| | 1379| 138k| goto yynewstate; 1380| | 1381| | 1382| |/*-----------------------------------------------------------. 1383| || yydefault -- do the default action for the current state. | 1384| |`-----------------------------------------------------------*/ 1385| 99.9k|yydefault: 1386| 99.9k| yyn = yydefact[yystate]; 1387| 99.9k| if (yyn == 0) ------------------ | Branch (1387:7): [True: 172, False: 99.7k] ------------------ 1388| 172| goto yyerrlab; 1389| 99.7k| goto yyreduce; 1390| | 1391| | 1392| |/*-----------------------------. 1393| || yyreduce -- Do a reduction. | 1394| |`-----------------------------*/ 1395| 99.7k|yyreduce: 1396| | /* yyn is the number of a rule to reduce with. */ 1397| 99.7k| yylen = yyr2[yyn]; 1398| | 1399| | /* If YYLEN is nonzero, implement the default value of the action: 1400| | '$$ = $1'. 1401| | 1402| | Otherwise, the following line sets YYVAL to garbage. 1403| | This behavior is undocumented and Bison 1404| | users should not rely upon it. Assigning to YYVAL 1405| | unconditionally makes the parser a bit smaller, and it avoids a 1406| | GCC warning that YYVAL may be used uninitialized. */ 1407| 99.7k| yyval = yyvsp[1-yylen]; 1408| | 1409| | 1410| 99.7k| YY_REDUCE_PRINT (yyn); 1411| 99.7k| switch (yyn) 1412| 99.7k| { 1413| 1.23k| case 2: ------------------ | Branch (1413:9): [True: 1.23k, False: 98.5k] ------------------ 1414| 1.23k|#line 128 "util_expr_parse.y" /* yacc.c:1648 */ 1415| 1.23k| { ctx->expr = (yyvsp[0].exVal); } 1416| 1.23k|#line 1415 "util_expr_parse.c" /* yacc.c:1648 */ 1417| 1.23k| break; 1418| | 1419| 17| case 3: ------------------ | Branch (1419:3): [True: 17, False: 99.7k] ------------------ 1420| 17|#line 129 "util_expr_parse.y" /* yacc.c:1648 */ 1421| 17| { ctx->expr = (yyvsp[0].exVal); } 1422| 17|#line 1421 "util_expr_parse.c" /* yacc.c:1648 */ 1423| 17| break; 1424| | 1425| 0| case 4: ------------------ | Branch (1425:3): [True: 0, False: 99.7k] ------------------ 1426| 0|#line 130 "util_expr_parse.y" /* yacc.c:1648 */ 1427| 0| { YYABORT; } ------------------ | | 738| 0|#define YYABORT goto yyabortlab ------------------ 1428| 0|#line 1427 "util_expr_parse.c" /* yacc.c:1648 */ 1429| 0| break; 1430| | 1431| 6.14k| case 5: ------------------ | Branch (1431:3): [True: 6.14k, False: 93.6k] ------------------ 1432| 6.14k|#line 133 "util_expr_parse.y" /* yacc.c:1648 */ 1433| 6.14k| { (yyval.exVal) = (yyvsp[0].exVal); } 1434| 6.14k|#line 1433 "util_expr_parse.c" /* yacc.c:1648 */ 1435| 6.14k| break; 1436| | 1437| 21.6k| case 6: ------------------ | Branch (1437:3): [True: 21.6k, False: 78.1k] ------------------ 1438| 21.6k|#line 134 "util_expr_parse.y" /* yacc.c:1648 */ 1439| 21.6k| { (yyval.exVal) = ap_expr_concat_make((yyvsp[-1].exVal), (yyvsp[0].exVal), ctx); } 1440| 21.6k|#line 1439 "util_expr_parse.c" /* yacc.c:1648 */ 1441| 21.6k| break; 1442| | 1443| 70| case 7: ------------------ | Branch (1443:3): [True: 70, False: 99.7k] ------------------ 1444| 70|#line 135 "util_expr_parse.y" /* yacc.c:1648 */ 1445| 70| { YYABORT; } ------------------ | | 738| 70|#define YYABORT goto yyabortlab ------------------ 1446| 0|#line 1445 "util_expr_parse.c" /* yacc.c:1648 */ 1447| 0| break; 1448| | 1449| 0| case 8: ------------------ | Branch (1449:3): [True: 0, False: 99.7k] ------------------ 1450| 0|#line 138 "util_expr_parse.y" /* yacc.c:1648 */ 1451| 0| { (yyval.exVal) = ap_expr_make(op_True, NULL, NULL, ctx); } 1452| 0|#line 1451 "util_expr_parse.c" /* yacc.c:1648 */ 1453| 0| break; 1454| | 1455| 0| case 9: ------------------ | Branch (1455:3): [True: 0, False: 99.7k] ------------------ 1456| 0|#line 139 "util_expr_parse.y" /* yacc.c:1648 */ 1457| 0| { (yyval.exVal) = ap_expr_make(op_False, NULL, NULL, ctx); } 1458| 0|#line 1457 "util_expr_parse.c" /* yacc.c:1648 */ 1459| 0| break; 1460| | 1461| 4| case 10: ------------------ | Branch (1461:3): [True: 4, False: 99.7k] ------------------ 1462| 4|#line 140 "util_expr_parse.y" /* yacc.c:1648 */ 1463| 4| { (yyval.exVal) = ap_expr_make(op_Not, (yyvsp[0].exVal), NULL, ctx); } 1464| 4|#line 1463 "util_expr_parse.c" /* yacc.c:1648 */ 1465| 4| break; 1466| | 1467| 1.40k| case 11: ------------------ | Branch (1467:3): [True: 1.40k, False: 98.3k] ------------------ 1468| 1.40k|#line 141 "util_expr_parse.y" /* yacc.c:1648 */ 1469| 1.40k| { (yyval.exVal) = ap_expr_make(op_Or, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1470| 1.40k|#line 1469 "util_expr_parse.c" /* yacc.c:1648 */ 1471| 1.40k| break; 1472| | 1473| 232| case 12: ------------------ | Branch (1473:3): [True: 232, False: 99.5k] ------------------ 1474| 232|#line 142 "util_expr_parse.y" /* yacc.c:1648 */ 1475| 232| { (yyval.exVal) = ap_expr_make(op_And, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1476| 232|#line 1475 "util_expr_parse.c" /* yacc.c:1648 */ 1477| 232| break; 1478| | 1479| 1.09k| case 13: ------------------ | Branch (1479:3): [True: 1.09k, False: 98.6k] ------------------ 1480| 1.09k|#line 143 "util_expr_parse.y" /* yacc.c:1648 */ 1481| 1.09k| { (yyval.exVal) = ap_expr_make(op_Comp, (yyvsp[0].exVal), NULL, ctx); } 1482| 1.09k|#line 1481 "util_expr_parse.c" /* yacc.c:1648 */ 1483| 1.09k| break; 1484| | 1485| 292| case 14: ------------------ | Branch (1485:3): [True: 292, False: 99.4k] ------------------ 1486| 292|#line 144 "util_expr_parse.y" /* yacc.c:1648 */ 1487| 292| { (yyval.exVal) = ap_expr_unary_op_make( (yyvsp[-1].cpVal), (yyvsp[0].exVal), ctx); } 1488| 292|#line 1487 "util_expr_parse.c" /* yacc.c:1648 */ 1489| 292| break; 1490| | 1491| 286| case 15: ------------------ | Branch (1491:3): [True: 286, False: 99.4k] ------------------ 1492| 286|#line 145 "util_expr_parse.y" /* yacc.c:1648 */ 1493| 286| { (yyval.exVal) = ap_expr_binary_op_make((yyvsp[-1].cpVal), (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1494| 286|#line 1493 "util_expr_parse.c" /* yacc.c:1648 */ 1495| 286| break; 1496| | 1497| 0| case 16: ------------------ | Branch (1497:3): [True: 0, False: 99.7k] ------------------ 1498| 0|#line 146 "util_expr_parse.y" /* yacc.c:1648 */ 1499| 0| { (yyval.exVal) = (yyvsp[-1].exVal); } 1500| 0|#line 1499 "util_expr_parse.c" /* yacc.c:1648 */ 1501| 0| break; 1502| | 1503| 0| case 17: ------------------ | Branch (1503:3): [True: 0, False: 99.7k] ------------------ 1504| 0|#line 147 "util_expr_parse.y" /* yacc.c:1648 */ 1505| 0| { YYABORT; } ------------------ | | 738| 0|#define YYABORT goto yyabortlab ------------------ 1506| 0|#line 1505 "util_expr_parse.c" /* yacc.c:1648 */ 1507| 0| break; 1508| | 1509| 0| case 18: ------------------ | Branch (1509:3): [True: 0, False: 99.7k] ------------------ 1510| 0|#line 150 "util_expr_parse.y" /* yacc.c:1648 */ 1511| 0| { (yyval.exVal) = ap_expr_make(op_EQ, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1512| 0|#line 1511 "util_expr_parse.c" /* yacc.c:1648 */ 1513| 0| break; 1514| | 1515| 0| case 19: ------------------ | Branch (1515:3): [True: 0, False: 99.7k] ------------------ 1516| 0|#line 151 "util_expr_parse.y" /* yacc.c:1648 */ 1517| 0| { (yyval.exVal) = ap_expr_make(op_NE, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1518| 0|#line 1517 "util_expr_parse.c" /* yacc.c:1648 */ 1519| 0| break; 1520| | 1521| 0| case 20: ------------------ | Branch (1521:3): [True: 0, False: 99.7k] ------------------ 1522| 0|#line 152 "util_expr_parse.y" /* yacc.c:1648 */ 1523| 0| { (yyval.exVal) = ap_expr_make(op_LT, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1524| 0|#line 1523 "util_expr_parse.c" /* yacc.c:1648 */ 1525| 0| break; 1526| | 1527| 0| case 21: ------------------ | Branch (1527:3): [True: 0, False: 99.7k] ------------------ 1528| 0|#line 153 "util_expr_parse.y" /* yacc.c:1648 */ 1529| 0| { (yyval.exVal) = ap_expr_make(op_LE, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1530| 0|#line 1529 "util_expr_parse.c" /* yacc.c:1648 */ 1531| 0| break; 1532| | 1533| 0| case 22: ------------------ | Branch (1533:3): [True: 0, False: 99.7k] ------------------ 1534| 0|#line 154 "util_expr_parse.y" /* yacc.c:1648 */ 1535| 0| { (yyval.exVal) = ap_expr_make(op_GT, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1536| 0|#line 1535 "util_expr_parse.c" /* yacc.c:1648 */ 1537| 0| break; 1538| | 1539| 0| case 23: ------------------ | Branch (1539:3): [True: 0, False: 99.7k] ------------------ 1540| 0|#line 155 "util_expr_parse.y" /* yacc.c:1648 */ 1541| 0| { (yyval.exVal) = ap_expr_make(op_GE, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1542| 0|#line 1541 "util_expr_parse.c" /* yacc.c:1648 */ 1543| 0| break; 1544| | 1545| 128| case 24: ------------------ | Branch (1545:3): [True: 128, False: 99.6k] ------------------ 1546| 128|#line 156 "util_expr_parse.y" /* yacc.c:1648 */ 1547| 128| { (yyval.exVal) = ap_expr_make(op_STR_EQ, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1548| 128|#line 1547 "util_expr_parse.c" /* yacc.c:1648 */ 1549| 128| break; 1550| | 1551| 0| case 25: ------------------ | Branch (1551:3): [True: 0, False: 99.7k] ------------------ 1552| 0|#line 157 "util_expr_parse.y" /* yacc.c:1648 */ 1553| 0| { (yyval.exVal) = ap_expr_make(op_STR_NE, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1554| 0|#line 1553 "util_expr_parse.c" /* yacc.c:1648 */ 1555| 0| break; 1556| | 1557| 112| case 26: ------------------ | Branch (1557:3): [True: 112, False: 99.6k] ------------------ 1558| 112|#line 158 "util_expr_parse.y" /* yacc.c:1648 */ 1559| 112| { (yyval.exVal) = ap_expr_make(op_STR_LT, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1560| 112|#line 1559 "util_expr_parse.c" /* yacc.c:1648 */ 1561| 112| break; 1562| | 1563| 0| case 27: ------------------ | Branch (1563:3): [True: 0, False: 99.7k] ------------------ 1564| 0|#line 159 "util_expr_parse.y" /* yacc.c:1648 */ 1565| 0| { (yyval.exVal) = ap_expr_make(op_STR_LE, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1566| 0|#line 1565 "util_expr_parse.c" /* yacc.c:1648 */ 1567| 0| break; 1568| | 1569| 44| case 28: ------------------ | Branch (1569:3): [True: 44, False: 99.7k] ------------------ 1570| 44|#line 160 "util_expr_parse.y" /* yacc.c:1648 */ 1571| 44| { (yyval.exVal) = ap_expr_make(op_STR_GT, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1572| 44|#line 1571 "util_expr_parse.c" /* yacc.c:1648 */ 1573| 44| break; 1574| | 1575| 0| case 29: ------------------ | Branch (1575:3): [True: 0, False: 99.7k] ------------------ 1576| 0|#line 161 "util_expr_parse.y" /* yacc.c:1648 */ 1577| 0| { (yyval.exVal) = ap_expr_make(op_STR_GE, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1578| 0|#line 1577 "util_expr_parse.c" /* yacc.c:1648 */ 1579| 0| break; 1580| | 1581| 208| case 30: ------------------ | Branch (1581:3): [True: 208, False: 99.5k] ------------------ 1582| 208|#line 162 "util_expr_parse.y" /* yacc.c:1648 */ 1583| 208| { (yyval.exVal) = ap_expr_make(op_REG, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1584| 208|#line 1583 "util_expr_parse.c" /* yacc.c:1648 */ 1585| 208| break; 1586| | 1587| 129| case 31: ------------------ | Branch (1587:3): [True: 129, False: 99.6k] ------------------ 1588| 129|#line 163 "util_expr_parse.y" /* yacc.c:1648 */ 1589| 129| { (yyval.exVal) = ap_expr_make(op_NRE, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1590| 129|#line 1589 "util_expr_parse.c" /* yacc.c:1648 */ 1591| 129| break; 1592| | 1593| 472| case 32: ------------------ | Branch (1593:3): [True: 472, False: 99.3k] ------------------ 1594| 472|#line 164 "util_expr_parse.y" /* yacc.c:1648 */ 1595| 472| { (yyval.exVal) = ap_expr_make(op_IN, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1596| 472|#line 1595 "util_expr_parse.c" /* yacc.c:1648 */ 1597| 472| break; 1598| | 1599| 7.31k| case 33: ------------------ | Branch (1599:3): [True: 7.31k, False: 92.4k] ------------------ 1600| 7.31k|#line 167 "util_expr_parse.y" /* yacc.c:1648 */ 1601| 7.31k| { (yyval.exVal) = ap_expr_make(op_Digit, (yyvsp[0].cpVal), NULL, ctx); } 1602| 7.31k|#line 1601 "util_expr_parse.c" /* yacc.c:1648 */ 1603| 7.31k| break; 1604| | 1605| 307| case 34: ------------------ | Branch (1605:3): [True: 307, False: 99.4k] ------------------ 1606| 307|#line 168 "util_expr_parse.y" /* yacc.c:1648 */ 1607| 307| { (yyval.exVal) = ap_expr_make(op_String, "", NULL, ctx); } 1608| 307|#line 1607 "util_expr_parse.c" /* yacc.c:1648 */ 1609| 307| break; 1610| | 1611| 107| case 35: ------------------ | Branch (1611:3): [True: 107, False: 99.6k] ------------------ 1612| 107|#line 169 "util_expr_parse.y" /* yacc.c:1648 */ 1613| 107| { (yyval.exVal) = (yyvsp[-1].exVal); } 1614| 107|#line 1613 "util_expr_parse.c" /* yacc.c:1648 */ 1615| 107| break; 1616| | 1617| 180| case 36: ------------------ | Branch (1617:3): [True: 180, False: 99.6k] ------------------ 1618| 180|#line 170 "util_expr_parse.y" /* yacc.c:1648 */ 1619| 180| { (yyval.exVal) = ap_expr_make(op_Concat, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1620| 180|#line 1619 "util_expr_parse.c" /* yacc.c:1648 */ 1621| 180| break; 1622| | 1623| 1| case 37: ------------------ | Branch (1623:3): [True: 1, False: 99.7k] ------------------ 1624| 1|#line 171 "util_expr_parse.y" /* yacc.c:1648 */ 1625| 1| { (yyval.exVal) = (yyvsp[0].exVal); } 1626| 1|#line 1625 "util_expr_parse.c" /* yacc.c:1648 */ 1627| 1| break; 1628| | 1629| 3.56k| case 38: ------------------ | Branch (1629:3): [True: 3.56k, False: 96.2k] ------------------ 1630| 3.56k|#line 172 "util_expr_parse.y" /* yacc.c:1648 */ 1631| 3.56k| { (yyval.exVal) = (yyvsp[0].exVal); } 1632| 3.56k|#line 1631 "util_expr_parse.c" /* yacc.c:1648 */ 1633| 3.56k| break; 1634| | 1635| 797| case 39: ------------------ | Branch (1635:3): [True: 797, False: 98.9k] ------------------ 1636| 797|#line 173 "util_expr_parse.y" /* yacc.c:1648 */ 1637| 797| { (yyval.exVal) = (yyvsp[0].exVal); } 1638| 797|#line 1637 "util_expr_parse.c" /* yacc.c:1648 */ 1639| 797| break; 1640| | 1641| 525| case 40: ------------------ | Branch (1641:3): [True: 525, False: 99.2k] ------------------ 1642| 525|#line 174 "util_expr_parse.y" /* yacc.c:1648 */ 1643| 525| { (yyval.exVal) = (yyvsp[0].exVal); } 1644| 525|#line 1643 "util_expr_parse.c" /* yacc.c:1648 */ 1645| 525| break; 1646| | 1647| 17| case 41: ------------------ | Branch (1647:3): [True: 17, False: 99.7k] ------------------ 1648| 17|#line 175 "util_expr_parse.y" /* yacc.c:1648 */ 1649| 17| { (yyval.exVal) = (yyvsp[-1].exVal); } 1650| 17|#line 1649 "util_expr_parse.c" /* yacc.c:1648 */ 1651| 17| break; 1652| | 1653| 627| case 42: ------------------ | Branch (1653:3): [True: 627, False: 99.1k] ------------------ 1654| 627|#line 178 "util_expr_parse.y" /* yacc.c:1648 */ 1655| 627| { (yyval.exVal) = (yyvsp[0].exVal); } 1656| 627|#line 1655 "util_expr_parse.c" /* yacc.c:1648 */ 1657| 627| break; 1658| | 1659| 932| case 43: ------------------ | Branch (1659:3): [True: 932, False: 98.8k] ------------------ 1660| 932|#line 179 "util_expr_parse.y" /* yacc.c:1648 */ 1661| 932| { (yyval.exVal) = (yyvsp[0].exVal); } 1662| 932|#line 1661 "util_expr_parse.c" /* yacc.c:1648 */ 1663| 932| break; 1664| | 1665| 0| case 44: ------------------ | Branch (1665:3): [True: 0, False: 99.7k] ------------------ 1666| 0|#line 180 "util_expr_parse.y" /* yacc.c:1648 */ 1667| 0| { (yyval.exVal) = (yyvsp[-1].exVal); } 1668| 0|#line 1667 "util_expr_parse.c" /* yacc.c:1648 */ 1669| 0| break; 1670| | 1671| 0| case 45: ------------------ | Branch (1671:3): [True: 0, False: 99.7k] ------------------ 1672| 0|#line 181 "util_expr_parse.y" /* yacc.c:1648 */ 1673| 0| { (yyval.exVal) = (yyvsp[-1].exVal); } 1674| 0|#line 1673 "util_expr_parse.c" /* yacc.c:1648 */ 1675| 0| break; 1676| | 1677| 16.7k| case 46: ------------------ | Branch (1677:3): [True: 16.7k, False: 83.0k] ------------------ 1678| 16.7k|#line 184 "util_expr_parse.y" /* yacc.c:1648 */ 1679| 16.7k| { (yyval.exVal) = ap_expr_make(op_String, (yyvsp[0].cpVal), NULL, ctx); } 1680| 16.7k|#line 1679 "util_expr_parse.c" /* yacc.c:1648 */ 1681| 16.7k| break; 1682| | 1683| 11.0k| case 47: ------------------ | Branch (1683:3): [True: 11.0k, False: 88.6k] ------------------ 1684| 11.0k|#line 185 "util_expr_parse.y" /* yacc.c:1648 */ 1685| 11.0k| { (yyval.exVal) = (yyvsp[0].exVal); } 1686| 11.0k|#line 1685 "util_expr_parse.c" /* yacc.c:1648 */ 1687| 11.0k| break; 1688| | 1689| 0| case 48: ------------------ | Branch (1689:3): [True: 0, False: 99.7k] ------------------ 1690| 0|#line 188 "util_expr_parse.y" /* yacc.c:1648 */ 1691| 0| { (yyval.exVal) = ap_expr_var_make((yyvsp[-1].cpVal), ctx); } 1692| 0|#line 1691 "util_expr_parse.c" /* yacc.c:1648 */ 1693| 0| break; 1694| | 1695| 0| case 49: ------------------ | Branch (1695:3): [True: 0, False: 99.7k] ------------------ 1696| 0|#line 189 "util_expr_parse.y" /* yacc.c:1648 */ 1697| 0| { (yyval.exVal) = ap_expr_str_func_make((yyvsp[-3].cpVal), (yyvsp[-1].exVal), ctx); } 1698| 0|#line 1697 "util_expr_parse.c" /* yacc.c:1648 */ 1699| 0| break; 1700| | 1701| 0| case 50: ------------------ | Branch (1701:3): [True: 0, False: 99.7k] ------------------ 1702| 0|#line 190 "util_expr_parse.y" /* yacc.c:1648 */ 1703| 0| { (yyval.exVal) = ap_expr_make(op_Bool, (yyvsp[-1].exVal), NULL, ctx); } 1704| 0|#line 1703 "util_expr_parse.c" /* yacc.c:1648 */ 1705| 0| break; 1706| | 1707| 0| case 51: ------------------ | Branch (1707:3): [True: 0, False: 99.7k] ------------------ 1708| 0|#line 191 "util_expr_parse.y" /* yacc.c:1648 */ 1709| 0| { (yyval.exVal) = ap_expr_make(op_Word, (yyvsp[-1].exVal), NULL, ctx); } 1710| 0|#line 1709 "util_expr_parse.c" /* yacc.c:1648 */ 1711| 0| break; 1712| | 1713| 11.0k| case 52: ------------------ | Branch (1713:3): [True: 11.0k, False: 88.6k] ------------------ 1714| 11.0k|#line 192 "util_expr_parse.y" /* yacc.c:1648 */ 1715| 11.0k| { (yyval.exVal) = ap_expr_backref_make((yyvsp[0].num), ctx); } 1716| 11.0k|#line 1715 "util_expr_parse.c" /* yacc.c:1648 */ 1717| 11.0k| break; 1718| | 1719| 504| case 53: ------------------ | Branch (1719:3): [True: 504, False: 99.2k] ------------------ 1720| 504|#line 195 "util_expr_parse.y" /* yacc.c:1648 */ 1721| 504| { (yyval.exVal) = ap_expr_str_func_make((yyvsp[-3].cpVal), (yyvsp[-1].exVal), ctx); } 1722| 504|#line 1721 "util_expr_parse.c" /* yacc.c:1648 */ 1723| 504| break; 1724| | 1725| 21| case 54: ------------------ | Branch (1725:3): [True: 21, False: 99.7k] ------------------ 1726| 21|#line 196 "util_expr_parse.y" /* yacc.c:1648 */ 1727| 21| { (yyval.exVal) = ap_expr_str_func_make((yyvsp[-3].cpVal), (yyvsp[-1].exVal), ctx); } 1728| 21|#line 1727 "util_expr_parse.c" /* yacc.c:1648 */ 1729| 21| break; 1730| | 1731| 932| case 55: ------------------ | Branch (1731:3): [True: 932, False: 98.8k] ------------------ 1732| 932|#line 199 "util_expr_parse.y" /* yacc.c:1648 */ 1733| 932| { (yyval.exVal) = ap_expr_list_func_make((yyvsp[-3].cpVal), (yyvsp[-1].exVal), ctx); } 1734| 932|#line 1733 "util_expr_parse.c" /* yacc.c:1648 */ 1735| 932| break; 1736| | 1737| 128| case 56: ------------------ | Branch (1737:3): [True: 128, False: 99.6k] ------------------ 1738| 128|#line 203 "util_expr_parse.y" /* yacc.c:1648 */ 1739| 128| { (yyval.exVal) = ap_expr_make(op_Sub, (yyvsp[0].exVal), (yyvsp[-2].exVal), ctx); } 1740| 128|#line 1739 "util_expr_parse.c" /* yacc.c:1648 */ 1741| 128| break; 1742| | 1743| 3.43k| case 57: ------------------ | Branch (1743:3): [True: 3.43k, False: 96.3k] ------------------ 1744| 3.43k|#line 204 "util_expr_parse.y" /* yacc.c:1648 */ 1745| 3.43k| { (yyval.exVal) = ap_expr_make(op_Sub, (yyvsp[-1].exVal), (yyvsp[-3].exVal), ctx); } 1746| 3.43k|#line 1745 "util_expr_parse.c" /* yacc.c:1648 */ 1747| 3.43k| break; 1748| | 1749| 541| case 58: ------------------ | Branch (1749:3): [True: 541, False: 99.2k] ------------------ 1750| 541|#line 207 "util_expr_parse.y" /* yacc.c:1648 */ 1751| 541| { (yyval.exVal) = ap_expr_make(op_Join, (yyvsp[0].exVal), NULL, ctx); } 1752| 541|#line 1751 "util_expr_parse.c" /* yacc.c:1648 */ 1753| 541| break; 1754| | 1755| 0| case 59: ------------------ | Branch (1755:3): [True: 0, False: 99.7k] ------------------ 1756| 0|#line 208 "util_expr_parse.y" /* yacc.c:1648 */ 1757| 0| { (yyval.exVal) = ap_expr_make(op_Join, (yyvsp[-1].exVal), NULL, ctx); } 1758| 0|#line 1757 "util_expr_parse.c" /* yacc.c:1648 */ 1759| 0| break; 1760| | 1761| 128| case 60: ------------------ | Branch (1761:3): [True: 128, False: 99.6k] ------------------ 1762| 128|#line 209 "util_expr_parse.y" /* yacc.c:1648 */ 1763| 128| { (yyval.exVal) = ap_expr_make(op_Join, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1764| 128|#line 1763 "util_expr_parse.c" /* yacc.c:1648 */ 1765| 128| break; 1766| | 1767| 128| case 61: ------------------ | Branch (1767:3): [True: 128, False: 99.6k] ------------------ 1768| 128|#line 210 "util_expr_parse.y" /* yacc.c:1648 */ 1769| 128| { (yyval.exVal) = ap_expr_make(op_Join, (yyvsp[-3].exVal), (yyvsp[-1].exVal), ctx); } 1770| 128|#line 1769 "util_expr_parse.c" /* yacc.c:1648 */ 1771| 128| break; 1772| | 1773| 128| case 62: ------------------ | Branch (1773:3): [True: 128, False: 99.6k] ------------------ 1774| 128|#line 213 "util_expr_parse.y" /* yacc.c:1648 */ 1775| 128| { (yyval.exVal) = ap_expr_make(op_Split, (yyvsp[0].exVal), (yyvsp[-2].exVal), ctx); } 1776| 128|#line 1775 "util_expr_parse.c" /* yacc.c:1648 */ 1777| 128| break; 1778| | 1779| 160| case 63: ------------------ | Branch (1779:3): [True: 160, False: 99.6k] ------------------ 1780| 160|#line 214 "util_expr_parse.y" /* yacc.c:1648 */ 1781| 160| { (yyval.exVal) = ap_expr_make(op_Split, (yyvsp[-1].exVal), (yyvsp[-3].exVal), ctx); } 1782| 160|#line 1781 "util_expr_parse.c" /* yacc.c:1648 */ 1783| 160| break; 1784| | 1785| 163| case 64: ------------------ | Branch (1785:3): [True: 163, False: 99.6k] ------------------ 1786| 163|#line 215 "util_expr_parse.y" /* yacc.c:1648 */ 1787| 163| { (yyval.exVal) = ap_expr_make(op_Split, (yyvsp[0].exVal), (yyvsp[-2].exVal), ctx); } 1788| 163|#line 1787 "util_expr_parse.c" /* yacc.c:1648 */ 1789| 163| break; 1790| | 1791| 176| case 65: ------------------ | Branch (1791:3): [True: 176, False: 99.6k] ------------------ 1792| 176|#line 216 "util_expr_parse.y" /* yacc.c:1648 */ 1793| 176| { (yyval.exVal) = ap_expr_make(op_Split, (yyvsp[-1].exVal), (yyvsp[-3].exVal), ctx); } 1794| 176|#line 1793 "util_expr_parse.c" /* yacc.c:1648 */ 1795| 176| break; 1796| | 1797| 22| case 66: ------------------ | Branch (1797:3): [True: 22, False: 99.7k] ------------------ 1798| 22|#line 219 "util_expr_parse.y" /* yacc.c:1648 */ 1799| 22| { (yyval.exVal) = ap_expr_make(op_ListElement, (yyvsp[0].exVal), NULL, ctx); } 1800| 22|#line 1799 "util_expr_parse.c" /* yacc.c:1648 */ 1801| 22| break; 1802| | 1803| 29| case 67: ------------------ | Branch (1803:3): [True: 29, False: 99.7k] ------------------ 1804| 29|#line 220 "util_expr_parse.y" /* yacc.c:1648 */ 1805| 29| { (yyval.exVal) = ap_expr_make(op_ListElement, (yyvsp[-2].exVal), (yyvsp[0].exVal), ctx); } 1806| 29|#line 1805 "util_expr_parse.c" /* yacc.c:1648 */ 1807| 29| break; 1808| | 1809| 970| case 68: ------------------ | Branch (1809:3): [True: 970, False: 98.8k] ------------------ 1810| 970|#line 223 "util_expr_parse.y" /* yacc.c:1648 */ 1811| 970| { 1812| 970| ap_expr_t *e = ap_expr_regex_make((yyvsp[-1].cpVal), NULL, (yyvsp[0].cpVal), ctx); 1813| 970| if (!e) { ------------------ | Branch (1813:21): [True: 0, False: 970] ------------------ 1814| 0| ctx->error = "Failed to compile regular expression"; 1815| 0| YYERROR; ------------------ | | 739| 0|#define YYERROR goto yyerrorlab ------------------ 1816| 0| } 1817| 970| (yyval.exVal) = e; 1818| 970| } 1819| 0|#line 1818 "util_expr_parse.c" /* yacc.c:1648 */ 1820| 0| break; 1821| | 1822| 4.79k| case 69: ------------------ | Branch (1822:3): [True: 4.79k, False: 94.9k] ------------------ 1823| 4.79k|#line 232 "util_expr_parse.y" /* yacc.c:1648 */ 1824| 4.79k| { 1825| 4.79k| ap_expr_t *e = ap_expr_regex_make((yyvsp[-2].cpVal), (yyvsp[-1].exVal), (yyvsp[0].cpVal), ctx); 1826| 4.79k| if (!e) { ------------------ | Branch (1826:21): [True: 0, False: 4.79k] ------------------ 1827| 0| ctx->error = "Failed to compile regular expression"; 1828| 0| YYERROR; ------------------ | | 739| 0|#define YYERROR goto yyerrorlab ------------------ 1829| 0| } 1830| 4.79k| (yyval.exVal) = e; 1831| 4.79k| } 1832| 0|#line 1831 "util_expr_parse.c" /* yacc.c:1648 */ 1833| 0| break; 1834| | 1835| 633| case 70: ------------------ | Branch (1835:3): [True: 633, False: 99.1k] ------------------ 1836| 633|#line 241 "util_expr_parse.y" /* yacc.c:1648 */ 1837| 633| { (yyval.exVal) = (yyvsp[0].exVal); } 1838| 633|#line 1837 "util_expr_parse.c" /* yacc.c:1648 */ 1839| 633| break; 1840| | 1841| 128| case 71: ------------------ | Branch (1841:3): [True: 128, False: 99.6k] ------------------ 1842| 128|#line 242 "util_expr_parse.y" /* yacc.c:1648 */ 1843| 128| { (yyval.exVal) = (yyvsp[0].exVal); } 1844| 128|#line 1843 "util_expr_parse.c" /* yacc.c:1648 */ 1845| 128| break; 1846| | 1847| | 1848| 0|#line 1847 "util_expr_parse.c" /* yacc.c:1648 */ 1849| 0| default: break; ------------------ | Branch (1849:7): [True: 0, False: 99.7k] ------------------ 1850| 99.7k| } 1851| | /* User semantic actions sometimes alter yychar, and that requires 1852| | that yytoken be updated with the new translation. We take the 1853| | approach of translating immediately before every use of yytoken. 1854| | One alternative is translating here after every semantic action, 1855| | but that translation would be missed if the semantic action invokes 1856| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1857| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1858| | incorrect destructor might then be invoked immediately. In the 1859| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 1860| | to an incorrect destructor call or verbose syntax error message 1861| | before the lookahead is translated. */ 1862| 99.7k| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1863| | 1864| 99.7k| YYPOPSTACK (yylen); ------------------ | | 1217| 99.7k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1865| 99.7k| yylen = 0; 1866| 99.7k| YY_STACK_PRINT (yyss, yyssp); 1867| | 1868| 99.7k| *++yyvsp = yyval; 1869| | 1870| | /* Now 'shift' the result of the reduction. Determine what state 1871| | that goes to, based on the state we popped back to and the rule 1872| | number reduced by. */ 1873| | 1874| 99.7k| yyn = yyr1[yyn]; 1875| | 1876| 99.7k| yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; ------------------ | | 435| 99.7k|#define YYNTOKENS 53 ------------------ 1877| 99.7k| if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) ------------------ | | 432| 184k|#define YYLAST 274 ------------------ | Branch (1877:7): [True: 84.9k, False: 14.8k] | Branch (1877:23): [True: 84.9k, False: 0] | Branch (1877:44): [True: 72.7k, False: 12.1k] ------------------ 1878| 72.7k| yystate = yytable[yystate]; 1879| 26.9k| else 1880| 26.9k| yystate = yydefgoto[yyn - YYNTOKENS]; ------------------ | | 435| 26.9k|#define YYNTOKENS 53 ------------------ 1881| | 1882| 99.7k| goto yynewstate; 1883| | 1884| | 1885| |/*--------------------------------------. 1886| || yyerrlab -- here on detecting error. | 1887| |`--------------------------------------*/ 1888| 172|yyerrlab: 1889| | /* Make sure we have latest lookahead translation. See comments at 1890| | user semantic actions for why this is necessary. */ 1891| 172| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 734| 172|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 734| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 449| 344| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 446| 172|#define YYMAXUTOK 301 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 445| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (449:4): [True: 172, False: 0] | | ------------------ ------------------ | Branch (1891:13): [True: 0, False: 172] ------------------ 1892| | 1893| | /* If not already recovering from an error, report this error. */ 1894| 172| if (!yyerrstatus) ------------------ | Branch (1894:7): [True: 172, False: 0] ------------------ 1895| 172| { 1896| 172| ++yynerrs; ------------------ | | 67| 172|#define yynerrs ap_expr_yynerrs ------------------ 1897| |#if ! YYERROR_VERBOSE 1898| | yyerror (ctx, YY_("syntax error")); 1899| |#else 1900| 172|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 1901| 172| yyssp, yytoken) 1902| 172| { 1903| 172| char const *yymsgp = YY_("syntax error"); ------------------ | | 243| 172|# define YY_(Msgid) Msgid ------------------ 1904| 172| int yysyntax_error_status; 1905| 172| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 1900| 172|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 1901| 172| yyssp, yytoken) ------------------ 1906| 172| if (yysyntax_error_status == 0) ------------------ | Branch (1906:13): [True: 172, False: 0] ------------------ 1907| 172| yymsgp = yymsg; 1908| 0| else if (yysyntax_error_status == 1) ------------------ | Branch (1908:18): [True: 0, False: 0] ------------------ 1909| 0| { 1910| 0| if (yymsg != yymsgbuf) ------------------ | Branch (1910:17): [True: 0, False: 0] ------------------ 1911| 0| YYSTACK_FREE (yymsg); ------------------ | | 341| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 360| 0|# define YYFREE free | | ------------------ ------------------ 1912| 0| yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); ------------------ | | 340| 0|# define YYSTACK_ALLOC YYMALLOC | | ------------------ | | | | 354| 0|# define YYMALLOC malloc | | ------------------ ------------------ 1913| 0| if (!yymsg) ------------------ | Branch (1913:17): [True: 0, False: 0] ------------------ 1914| 0| { 1915| 0| yymsg = yymsgbuf; 1916| 0| yymsg_alloc = sizeof yymsgbuf; 1917| 0| yysyntax_error_status = 2; 1918| 0| } 1919| 0| else 1920| 0| { 1921| 0| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 1900| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 1901| 0| yyssp, yytoken) ------------------ 1922| 0| yymsgp = yymsg; 1923| 0| } 1924| 0| } 1925| 172| yyerror (ctx, yymsgp); ------------------ | | 65| 172|#define yyerror ap_expr_yyerror ------------------ 1926| 172| if (yysyntax_error_status == 2) ------------------ | Branch (1926:13): [True: 0, False: 172] ------------------ 1927| 0| goto yyexhaustedlab; 1928| 172| } 1929| 172|# undef YYSYNTAX_ERROR 1930| 172|#endif 1931| 172| } 1932| | 1933| | 1934| | 1935| 172| if (yyerrstatus == 3) ------------------ | Branch (1935:7): [True: 0, False: 172] ------------------ 1936| 0| { 1937| | /* If just tried and failed to reuse lookahead token after an 1938| | error, discard it. */ 1939| | 1940| 0| if (yychar <= YYEOF) ------------------ | | 735| 0|#define YYEOF 0 ------------------ | Branch (1940:11): [True: 0, False: 0] ------------------ 1941| 0| { 1942| | /* Return failure if at end of input. */ 1943| 0| if (yychar == YYEOF) ------------------ | | 735| 0|#define YYEOF 0 ------------------ | Branch (1943:15): [True: 0, False: 0] ------------------ 1944| 0| YYABORT; ------------------ | | 738| 0|#define YYABORT goto yyabortlab ------------------ 1945| 0| } 1946| 0| else 1947| 0| { 1948| 0| yydestruct ("Error: discarding", 1949| 0| yytoken, &yylval, ctx); 1950| 0| yychar = YYEMPTY; ------------------ | | 734| 0|#define YYEMPTY (-2) ------------------ 1951| 0| } 1952| 0| } 1953| | 1954| | /* Else will try to reuse lookahead token after shifting the error 1955| | token. */ 1956| 172| goto yyerrlab1; 1957| | 1958| | 1959| |/*---------------------------------------------------. 1960| || yyerrorlab -- error raised explicitly by YYERROR. | 1961| |`---------------------------------------------------*/ 1962| 172|yyerrorlab: 1963| | 1964| | /* Pacify compilers like GCC when the user code never invokes 1965| | YYERROR and the label yyerrorlab therefore never appears in user 1966| | code. */ 1967| 0| if (/*CONSTCOND*/ 0) ------------------ | Branch (1967:21): [Folded - Ignored] ------------------ 1968| 0| goto yyerrorlab; 1969| | 1970| | /* Do not reclaim the symbols of the rule whose action triggered 1971| | this YYERROR. */ 1972| 0| YYPOPSTACK (yylen); ------------------ | | 1217| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1973| 0| yylen = 0; 1974| 0| YY_STACK_PRINT (yyss, yyssp); 1975| 0| yystate = *yyssp; 1976| 0| goto yyerrlab1; 1977| | 1978| | 1979| |/*-------------------------------------------------------------. 1980| || yyerrlab1 -- common code for both syntax error and YYERROR. | 1981| |`-------------------------------------------------------------*/ 1982| 172|yyerrlab1: 1983| 172| yyerrstatus = 3; /* Each real token shifted decrements this. */ 1984| | 1985| 172| for (;;) 1986| 30.6k| { 1987| 30.6k| yyn = yypact[yystate]; 1988| 30.6k| if (!yypact_value_is_default (yyn)) ------------------ | | 550| 30.6k| (!!((Yystate) == (-38))) ------------------ | Branch (1988:11): [True: 30.6k, False: 0] ------------------ 1989| 30.6k| { 1990| 30.6k| yyn += YYTERROR; ------------------ | | 762| 30.6k|#define YYTERROR 1 ------------------ 1991| 30.6k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 432| 47.7k|#define YYLAST 274 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 762| 17.1k|#define YYTERROR 1 ------------------ | Branch (1991:15): [True: 17.1k, False: 13.4k] | Branch (1991:27): [True: 17.1k, False: 0] | Branch (1991:44): [True: 0, False: 17.1k] ------------------ 1992| 0| { 1993| 0| yyn = yytable[yyn]; 1994| 0| if (0 < yyn) ------------------ | Branch (1994:19): [True: 0, False: 0] ------------------ 1995| 0| break; 1996| 0| } 1997| 30.6k| } 1998| | 1999| | /* Pop the current state because it cannot handle the error token. */ 2000| 30.6k| if (yyssp == yyss) ------------------ | Branch (2000:11): [True: 172, False: 30.4k] ------------------ 2001| 172| YYABORT; ------------------ | | 738| 172|#define YYABORT goto yyabortlab ------------------ 2002| | 2003| | 2004| 30.4k| yydestruct ("Error: popping", 2005| 30.4k| yystos[yystate], yyvsp, ctx); 2006| 30.4k| YYPOPSTACK (1); ------------------ | | 1217| 30.4k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2007| 30.4k| yystate = *yyssp; 2008| 30.4k| YY_STACK_PRINT (yyss, yyssp); 2009| 30.4k| } 2010| | 2011| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2012| 0| *++yyvsp = yylval; 2013| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 2014| | 2015| | 2016| | /* Shift the error token. */ 2017| 0| YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2018| | 2019| 0| yystate = yyn; 2020| 0| goto yynewstate; 2021| | 2022| | 2023| |/*-------------------------------------. 2024| || yyacceptlab -- YYACCEPT comes here. | 2025| |`-------------------------------------*/ 2026| 1.24k|yyacceptlab: 2027| 1.24k| yyresult = 0; 2028| 1.24k| goto yyreturn; 2029| | 2030| |/*-----------------------------------. 2031| || yyabortlab -- YYABORT comes here. | 2032| |`-----------------------------------*/ 2033| 242|yyabortlab: 2034| 242| yyresult = 1; 2035| 242| goto yyreturn; 2036| | 2037| 0|#if !defined yyoverflow || YYERROR_VERBOSE 2038| |/*-------------------------------------------------. 2039| || yyexhaustedlab -- memory exhaustion comes here. | 2040| |`-------------------------------------------------*/ 2041| 2|yyexhaustedlab: 2042| 2| yyerror (ctx, YY_("memory exhausted")); ------------------ | | 65| 2|#define yyerror ap_expr_yyerror ------------------ yyerror (ctx, YY_("memory exhausted")); ------------------ | | 243| 2|# define YY_(Msgid) Msgid ------------------ 2043| 2| yyresult = 2; 2044| | /* Fall through. */ 2045| 2|#endif 2046| | 2047| 1.48k|yyreturn: 2048| 1.48k| if (yychar != YYEMPTY) ------------------ | | 734| 1.48k|#define YYEMPTY (-2) ------------------ | Branch (2048:7): [True: 172, False: 1.31k] ------------------ 2049| 172| { 2050| | /* Make sure we have latest lookahead translation. See comments at 2051| | user semantic actions for why this is necessary. */ 2052| 172| yytoken = YYTRANSLATE (yychar); ------------------ | | 449| 172| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 446| 172|#define YYMAXUTOK 301 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 445| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (449:4): [True: 172, False: 0] | | ------------------ ------------------ 2053| 172| yydestruct ("Cleanup: discarding lookahead", 2054| 172| yytoken, &yylval, ctx); 2055| 172| } 2056| | /* Do not reclaim the symbols of the rule whose action triggered 2057| | this YYABORT or YYACCEPT. */ 2058| 1.48k| YYPOPSTACK (yylen); ------------------ | | 1217| 1.48k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2059| 1.48k| YY_STACK_PRINT (yyss, yyssp); 2060| 37.1k| while (yyssp != yyss) ------------------ | Branch (2060:10): [True: 35.6k, False: 1.48k] ------------------ 2061| 35.6k| { 2062| 35.6k| yydestruct ("Cleanup: popping", 2063| 35.6k| yystos[*yyssp], yyvsp, ctx); 2064| 35.6k| YYPOPSTACK (1); ------------------ | | 1217| 35.6k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2065| 35.6k| } 2066| 1.48k|#ifndef yyoverflow 2067| 1.48k| if (yyss != yyssa) ------------------ | Branch (2067:7): [True: 42, False: 1.44k] ------------------ 2068| 42| YYSTACK_FREE (yyss); ------------------ | | 341| 42|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 360| 42|# define YYFREE free | | ------------------ ------------------ 2069| 1.48k|#endif 2070| 1.48k|#if YYERROR_VERBOSE 2071| 1.48k| if (yymsg != yymsgbuf) ------------------ | Branch (2071:7): [True: 0, False: 1.48k] ------------------ 2072| 0| YYSTACK_FREE (yymsg); ------------------ | | 341| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 360| 0|# define YYFREE free | | ------------------ ------------------ 2073| 1.48k|#endif 2074| 1.48k| return yyresult; 2075| 2|} ap_expr_yyerror: 2080| 174|{ 2081| | /* s is allocated on the stack */ 2082| 174| ctx->error = apr_pstrdup(ctx->ptemp, s); 2083| 174|} util_expr_parse.c:yysyntax_error: 1012| 172|{ 1013| 172| YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 222| 172|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 81| 172|# define YY_NULLPTR 0 ------------------ 1014| 172| YYSIZE_T yysize = yysize0; ------------------ | | 222| 172|# define YYSIZE_T __SIZE_TYPE__ ------------------ 1015| 172| enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1016| | /* Internationalized format string. */ 1017| 172| const char *yyformat = YY_NULLPTR; ------------------ | | 81| 172|# define YY_NULLPTR 0 ------------------ 1018| | /* Arguments of yyformat. */ 1019| 172| char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1020| | /* Number of reported tokens (one for the "unexpected", one per 1021| | "expected"). */ 1022| 172| int yycount = 0; 1023| | 1024| | /* There are many possibilities here to consider: 1025| | - If this state is a consistent state with a default action, then 1026| | the only way this function was invoked is if the default action 1027| | is an error action. In that case, don't check for expected 1028| | tokens because there are none. 1029| | - The only way there can be no lookahead present (in yychar) is if 1030| | this state is a consistent state with a default action. Thus, 1031| | detecting the absence of a lookahead is sufficient to determine 1032| | that there is no unexpected or expected token to report. In that 1033| | case, just report a simple "syntax error". 1034| | - Don't assume there isn't a lookahead just because this state is a 1035| | consistent state with a default action. There might have been a 1036| | previous inconsistent state, consistent state with a non-default 1037| | action, or user semantic action that manipulated yychar. 1038| | - Of course, the expected token list depends on states to have 1039| | correct lookahead information, and it depends on the parser not 1040| | to perform extra reductions after fetching a lookahead from the 1041| | scanner and before detecting a syntax error. Thus, state merging 1042| | (from LALR or IELR) and default reductions corrupt the expected 1043| | token list. However, the list is correct for canonical LR with 1044| | one exception: it will still contain any token that will not be 1045| | accepted due to an error action in a later state. 1046| | */ 1047| 172| if (yytoken != YYEMPTY) ------------------ | | 734| 172|#define YYEMPTY (-2) ------------------ | Branch (1047:7): [True: 172, False: 0] ------------------ 1048| 172| { 1049| 172| int yyn = yypact[*yyssp]; 1050| 172| yyarg[yycount++] = yytname[yytoken]; 1051| 172| if (!yypact_value_is_default (yyn)) ------------------ | | 550| 172| (!!((Yystate) == (-38))) ------------------ | Branch (1051:11): [True: 172, False: 0] ------------------ 1052| 172| { 1053| | /* Start YYX at -YYN if negative to avoid negative indexes in 1054| | YYCHECK. In other words, skip the first -YYN actions for 1055| | this state because they are default actions. */ 1056| 172| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1056:26): [True: 100, False: 72] ------------------ 1057| | /* Stay within bounds of both yycheck and yytname. */ 1058| 172| int yychecklim = YYLAST - yyn + 1; ------------------ | | 432| 172|#define YYLAST 274 ------------------ 1059| 172| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 435| 172|#define YYNTOKENS 53 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 435| 171|#define YYNTOKENS 53 ------------------ | Branch (1059:24): [True: 1, False: 171] ------------------ 1060| 172| int yyx; 1061| | 1062| 4.82k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1062:32): [True: 4.68k, False: 134] ------------------ 1063| 4.68k| if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR ------------------ | | 762| 5.02k|#define YYTERROR 1 ------------------ | Branch (1063:17): [True: 333, False: 4.35k] | Branch (1063:46): [True: 333, False: 0] ------------------ 1064| 4.68k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 555| 0| 0 ------------------ | Branch (1064:20): [Folded - Ignored] ------------------ 1065| 333| { 1066| 333| if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ------------------ | Branch (1066:21): [True: 38, False: 295] ------------------ 1067| 38| { 1068| 38| yycount = 1; 1069| 38| yysize = yysize0; 1070| 38| break; 1071| 38| } 1072| 295| yyarg[yycount++] = yytname[yyx]; 1073| 295| { 1074| 295| YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 222| 295|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 81| 295|# define YY_NULLPTR 0 ------------------ 1075| 295| if (! (yysize <= yysize1 ------------------ | Branch (1075:26): [True: 295, False: 0] ------------------ 1076| 295| && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 343| 295|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 233| 295|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1076:29): [True: 295, False: 0] ------------------ 1077| 0| return 2; 1078| 295| yysize = yysize1; 1079| 295| } 1080| 295| } 1081| 172| } 1082| 172| } 1083| | 1084| 172| switch (yycount) 1085| 172| { 1086| 0|# define YYCASE_(N, S) \ 1087| 0| case N: \ 1088| 0| yyformat = S; \ 1089| 0| break 1090| 0| default: /* Avoid compiler warnings. */ ------------------ | Branch (1090:5): [True: 0, False: 172] ------------------ 1091| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1087| 0| case N: \ | | ------------------ | | | Branch (1087:7): [True: 0, False: 172] | | ------------------ | | 1088| 0| yyformat = S; \ | | 1089| 0| break ------------------ 1092| 38| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1087| 38| case N: \ | | ------------------ | | | Branch (1087:7): [True: 38, False: 134] | | ------------------ | | 1088| 38| yyformat = S; \ | | 1089| 38| break ------------------ 1093| 130| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1087| 130| case N: \ | | ------------------ | | | Branch (1087:7): [True: 130, False: 42] | | ------------------ | | 1088| 130| yyformat = S; \ | | 1089| 130| break ------------------ 1094| 1| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1087| 1| case N: \ | | ------------------ | | | Branch (1087:7): [True: 1, False: 171] | | ------------------ | | 1088| 1| yyformat = S; \ | | 1089| 1| break ------------------ 1095| 1| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1087| 1| case N: \ | | ------------------ | | | Branch (1087:7): [True: 1, False: 171] | | ------------------ | | 1088| 1| yyformat = S; \ | | 1089| 1| break ------------------ 1096| 172| YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ------------------ | | 1087| 2| case N: \ | | ------------------ | | | Branch (1087:7): [True: 2, False: 170] | | ------------------ | | 1088| 2| yyformat = S; \ | | 1089| 2| break ------------------ 1097| 172|# undef YYCASE_ 1098| 172| } 1099| | 1100| 172| { 1101| 172| YYSIZE_T yysize1 = yysize + yystrlen (yyformat); ------------------ | | 222| 172|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize1 = yysize + yystrlen (yyformat); ------------------ | | 919| 172|# define yystrlen strlen ------------------ 1102| 172| if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 343| 172|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 233| 172|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1102:12): [True: 172, False: 0] | Branch (1102:33): [True: 172, False: 0] ------------------ 1103| 0| return 2; 1104| 172| yysize = yysize1; 1105| 172| } 1106| | 1107| 172| if (*yymsg_alloc < yysize) ------------------ | Branch (1107:7): [True: 0, False: 172] ------------------ 1108| 0| { 1109| 0| *yymsg_alloc = 2 * yysize; 1110| 0| if (! (yysize <= *yymsg_alloc ------------------ | Branch (1110:14): [True: 0, False: 0] ------------------ 1111| 0| && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 343| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 233| 0|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1111:17): [True: 0, False: 0] ------------------ 1112| 0| *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; ------------------ | | 343| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 233| 0|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ 1113| 0| return 1; 1114| 0| } 1115| | 1116| | /* Avoid sprintf, as that infringes on the user's name space. 1117| | Don't have undefined behavior even if the translation 1118| | produced a string with the wrong number of "%s"s. */ 1119| 172| { 1120| 172| char *yyp = *yymsg; 1121| 172| int yyi = 0; 1122| 6.43k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1122:12): [True: 6.25k, False: 172] ------------------ 1123| 6.25k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1123:11): [True: 315, False: 5.94k] | Branch (1123:26): [True: 315, False: 0] | Branch (1123:48): [True: 315, False: 0] ------------------ 1124| 315| { 1125| 315| yyp += yytnamerr (yyp, yyarg[yyi++]); 1126| 315| yyformat += 2; 1127| 315| } 1128| 5.94k| else 1129| 5.94k| { 1130| 5.94k| yyp++; 1131| 5.94k| yyformat++; 1132| 5.94k| } 1133| 172| } 1134| 172| return 0; 1135| 172|} util_expr_parse.c:yytnamerr: 963| 782|{ 964| 782| if (*yystr == '"') ------------------ | Branch (964:7): [True: 300, False: 482] ------------------ 965| 300| { 966| 300| YYSIZE_T yyn = 0; ------------------ | | 222| 300|# define YYSIZE_T __SIZE_TYPE__ ------------------ 967| 300| char const *yyp = yystr; 968| | 969| 300| for (;;) 970| 4.32k| switch (*++yyp) 971| 4.32k| { 972| 0| case '\'': ------------------ | Branch (972:11): [True: 0, False: 4.32k] ------------------ 973| 0| case ',': ------------------ | Branch (973:11): [True: 0, False: 4.32k] ------------------ 974| 0| goto do_not_strip_quotes; 975| | 976| 0| case '\\': ------------------ | Branch (976:11): [True: 0, False: 4.32k] ------------------ 977| 0| if (*++yyp != '\\') ------------------ | Branch (977:17): [True: 0, False: 0] ------------------ 978| 0| goto do_not_strip_quotes; 979| | /* Fall through. */ 980| 4.02k| default: ------------------ | Branch (980:11): [True: 4.02k, False: 300] ------------------ 981| 4.02k| if (yyres) ------------------ | Branch (981:17): [True: 982, False: 3.04k] ------------------ 982| 982| yyres[yyn] = *yyp; 983| 4.02k| yyn++; 984| 4.02k| break; 985| | 986| 300| case '"': ------------------ | Branch (986:11): [True: 300, False: 4.02k] ------------------ 987| 300| if (yyres) ------------------ | Branch (987:17): [True: 74, False: 226] ------------------ 988| 74| yyres[yyn] = '\0'; 989| 300| return yyn; 990| 4.32k| } 991| 0| do_not_strip_quotes: ; 992| 0| } 993| | 994| 482| if (! yyres) ------------------ | Branch (994:7): [True: 241, False: 241] ------------------ 995| 241| return yystrlen (yystr); ------------------ | | 919| 241|# define yystrlen strlen ------------------ 996| | 997| 241| return yystpcpy (yyres, yystr) - yyres; ------------------ | | 935| 241|# define yystpcpy stpcpy ------------------ 998| 482|} util_expr_parse.c:yydestruct: 1144| 66.3k|{ 1145| 66.3k| YYUSE (yyvaluep); ------------------ | | 276| 66.3k|# define YYUSE(E) ((void) (E)) ------------------ 1146| 66.3k| YYUSE (ctx); ------------------ | | 276| 66.3k|# define YYUSE(E) ((void) (E)) ------------------ 1147| 66.3k| if (!yymsg) ------------------ | Branch (1147:7): [True: 0, False: 66.3k] ------------------ 1148| 0| yymsg = "Deleting"; 1149| 66.3k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1150| | 1151| 66.3k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1152| 66.3k| YYUSE (yytype); ------------------ | | 276| 66.3k|# define YYUSE(E) ((void) (E)) ------------------ 1153| 66.3k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1154| 66.3k|} ap_expr_yylex: 972| 138k|{ 973| 138k| yy_state_type yy_current_state; 974| 138k| char *yy_cp, *yy_bp; 975| 138k| int yy_act; 976| 138k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 977| | 978| 138k| yylval = yylval_param; ------------------ | | 786| 138k| # define yylval yyg->yylval_r ------------------ 979| | 980| 138k| if ( !yyg->yy_init ) ------------------ | Branch (980:7): [True: 1.48k, False: 137k] ------------------ 981| 1.48k| { 982| 1.48k| yyg->yy_init = 1; 983| | 984| |#ifdef YY_USER_INIT 985| | YY_USER_INIT; 986| |#endif 987| | 988| 1.48k| if ( ! yyg->yy_start ) ------------------ | Branch (988:8): [True: 1.48k, False: 0] ------------------ 989| 1.48k| yyg->yy_start = 1; /* first start state */ 990| | 991| 1.48k| if ( ! yyin ) ------------------ | | 118| 1.48k|#define yyin yyg->yyin_r ------------------ | Branch (991:8): [True: 1.48k, False: 0] ------------------ 992| 1.48k| yyin = stdin; ------------------ | | 118| 1.48k|#define yyin yyg->yyin_r ------------------ 993| | 994| 1.48k| if ( ! yyout ) ------------------ | | 119| 1.48k|#define yyout yyg->yyout_r ------------------ | Branch (994:8): [True: 1.48k, False: 0] ------------------ 995| 1.48k| yyout = stdout; ------------------ | | 119| 1.48k|#define yyout yyg->yyout_r ------------------ 996| | 997| 1.48k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 269| 1.48k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 0, False: 1.48k] | | ------------------ | | 270| 1.48k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 1.48k| : NULL) ------------------ | Branch (997:8): [True: 1.48k, False: 0] ------------------ 998| 1.48k| ap_expr_yyensure_buffer_stack (yyscanner); 999| 1.48k| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 276| 1.48k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1000| 1.48k| ap_expr_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); ------------------ | | 118| 1.48k|#define yyin yyg->yyin_r ------------------ ap_expr_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); ------------------ | | 157| 1.48k|#define YY_BUF_SIZE 16384 ------------------ 1001| 1.48k| } 1002| | 1003| 1.48k| ap_expr_yy_load_buffer_state(yyscanner ); 1004| 1.48k| } 1005| | 1006| 138k| { 1007| 138k|#line 179 "util_expr_scan.l" 1008| | 1009| | 1010| | 1011| | /* 1012| | * Set initial state for string expressions 1013| | */ 1014| 138k| if (yyextra->at_start) { ------------------ | | 120| 138k|#define yyextra yyg->yyextra_r ------------------ | Branch (1014:7): [True: 1.48k, False: 137k] ------------------ 1015| 1.48k| yyextra->at_start = 0; ------------------ | | 120| 1.48k|#define yyextra yyg->yyextra_r ------------------ 1016| 1.48k| if (yyextra->flags & AP_EXPR_FLAG_STRING_RESULT) { ------------------ | | 120| 1.48k|#define yyextra yyg->yyextra_r ------------------ if (yyextra->flags & AP_EXPR_FLAG_STRING_RESULT) { ------------------ | | 68| 1.48k|#define AP_EXPR_FLAG_STRING_RESULT 8 ------------------ | Branch (1016:9): [True: 1.29k, False: 193] ------------------ 1017| 1.29k| STATE_PUSH(str, 1); ------------------ | | 685| 1.29k|#define STATE_PUSH(st, sk) do { \ | | 686| 1.29k| yy_push_state((st), yyscanner); \ | | 687| 1.29k| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 1.29k| STACK_PUSH(); \ | | ------------------ | | | | 661| 1.29k|#define STACK_PUSH() do { \ | | | | 662| 1.29k| ap_expr_parser_stack_t *sk; \ | | | | 663| 1.29k| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 1.29k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 0, False: 1.29k] | | | | ------------------ | | | | 664| 0| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 0| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 0| } \ | | | | 667| 1.29k| else { \ | | | | 668| 1.29k| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 1.29k| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 1.29k|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 1.29k|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 1.29k|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 1.29k| } \ | | | | 670| 1.29k| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 1.29k| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 1.29k| sk->scan_flag = 0; \ | | | | 673| 1.29k| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 1.29k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 1.29k| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 1.29k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 1.29k|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 1.29k| } \ | | 690| 1.29k|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1018| 1.29k| return T_EXPR_STRING; 1019| 1.29k| } 1020| 193| else { 1021| 193| STATE_PUSH(expr, 1); ------------------ | | 685| 193|#define STATE_PUSH(st, sk) do { \ | | 686| 193| yy_push_state((st), yyscanner); \ | | 687| 193| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 193| STACK_PUSH(); \ | | ------------------ | | | | 661| 193|#define STACK_PUSH() do { \ | | | | 662| 193| ap_expr_parser_stack_t *sk; \ | | | | 663| 193| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 193|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 0, False: 193] | | | | ------------------ | | | | 664| 0| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 0| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 0| } \ | | | | 667| 193| else { \ | | | | 668| 193| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 193| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 193|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 193|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 193|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 193| } \ | | | | 670| 193| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 193| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 193| sk->scan_flag = 0; \ | | | | 673| 193| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 193|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 193| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 193|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 193|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 193| } \ | | 690| 193|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1022| 193| return T_EXPR_BOOL; 1023| 193| } 1024| 1.48k| } 1025| | 1026| | 1027| | /* 1028| | * Back off INITIAL pushes 1029| | */ 1030| 137k|#line 1031 "util_expr_scan.c" 1031| | 1032| 545k| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1032:23): [Folded - Ignored] ------------------ 1033| 545k| { 1034| 545k| yy_cp = yyg->yy_c_buf_p; 1035| | 1036| | /* Support of yytext. */ 1037| 545k| *yy_cp = yyg->yy_hold_char; 1038| | 1039| | /* yy_bp points to the position in yy_ch_buf of the start of 1040| | * the current run. 1041| | */ 1042| 545k| yy_bp = yy_cp; 1043| | 1044| 545k| yy_current_state = yyg->yy_start; 1045| 549k|yy_match: 1046| 549k| do 1047| 18.0M| { 1048| 18.0M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 108| 18.0M|#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ------------------ 1049| 18.0M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1049:9): [True: 17.4M, False: 546k] ------------------ 1050| 17.4M| { 1051| 17.4M| yyg->yy_last_accepting_state = yy_current_state; 1052| 17.4M| yyg->yy_last_accepting_cpos = yy_cp; 1053| 17.4M| } 1054| 34.2M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1054:12): [True: 16.1M, False: 18.0M] ------------------ 1055| 16.1M| { 1056| 16.1M| yy_current_state = (int) yy_def[yy_current_state]; 1057| 16.1M| if ( yy_current_state >= 155 ) ------------------ | Branch (1057:10): [True: 15.6M, False: 556k] ------------------ 1058| 15.6M| yy_c = yy_meta[(unsigned int) yy_c]; 1059| 16.1M| } 1060| 18.0M| yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; 1061| 18.0M| ++yy_cp; 1062| 18.0M| } 1063| 18.0M| while ( yy_current_state != 154 ); ------------------ | Branch (1063:11): [True: 17.4M, False: 549k] ------------------ 1064| 549k| yy_cp = yyg->yy_last_accepting_cpos; 1065| 549k| yy_current_state = yyg->yy_last_accepting_state; 1066| | 1067| 550k|yy_find_action: 1068| 550k| yy_act = yy_accept[yy_current_state]; 1069| | 1070| 550k| YY_DO_BEFORE_ACTION; ------------------ | | 344| 550k| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 333| 550k|#define yytext_ptr yytext_r | | ------------------ | | 345| 550k| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 121| 550k|#define yyleng yyg->yyleng_r | | ------------------ | | 346| 550k| yyg->yy_hold_char = *yy_cp; \ | | 347| 550k| *yy_cp = '\0'; \ | | 348| 550k| yyg->yy_c_buf_p = yy_cp; ------------------ 1071| | 1072| 553k|do_action: /* This label is used only to access EOF actions. */ 1073| | 1074| 553k| switch ( yy_act ) 1075| 553k| { /* beginning of action switch */ 1076| 0| case 0: /* must back up */ ------------------ | Branch (1076:4): [True: 0, False: 553k] ------------------ 1077| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1078| 0| *yy_cp = yyg->yy_hold_char; 1079| 0| yy_cp = yyg->yy_last_accepting_cpos; 1080| 0| yy_current_state = yyg->yy_last_accepting_state; 1081| 0| goto yy_find_action; 1082| | 1083| 1.24k|case YY_STATE_EOF(str): ------------------ | | 141| 1.24k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 1.24k|#define YY_END_OF_BUFFER 74 | | ------------------ ------------------ | Branch (1083:1): [True: 1.24k, False: 552k] ------------------ 1084| 1.24k|#line 201 "util_expr_scan.l" 1085| 1.24k|{ 1086| 1.24k| STATE_POP(0); /* */ ------------------ | | 692| 1.24k|#define STATE_POP(sk) do { \ | | 693| 1.24k| if ((sk)) { \ | | ------------------ | | | Branch (693:9): [Folded - Ignored] | | ------------------ | | 694| 0| STACK_POP(); \ | | ------------------ | | | | 677| 0|#define STACK_POP() do { \ | | | | 678| 0| ap_expr_parser_stack_t *sk; \ | | | | 679| 0| sk = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 680| 0| yyextra->current = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 681| 0| sk->next = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 682| 0| yyextra->spares = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 683| 0|} while (0) | | | | ------------------ | | | | | Branch (683:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 695| 0| } \ | | 696| 1.24k| yy_pop_state(yyscanner); \ | | 697| 1.24k|} while (0) | | ------------------ | | | Branch (697:10): [Folded - Ignored] | | ------------------ ------------------ 1087| 1.24k| if (YY_START != INITIAL) { ------------------ | | 137| 1.24k|#define YY_START ((yyg->yy_start - 1) / 2) ------------------ if (YY_START != INITIAL) { ------------------ | | 725| 1.24k|#define INITIAL 0 ------------------ | Branch (1087:9): [True: 14, False: 1.22k] ------------------ 1088| 14| PERROR("Unterminated string"); ------------------ | | 645| 14|#define PERROR(msg) do { \ | | 646| 14| yyextra->error2 = msg; \ | | ------------------ | | | | 120| 14|#define yyextra yyg->yyextra_r | | ------------------ | | 647| 14| return T_ERROR; \ | | 648| 14|} while (0) | | ------------------ | | | Branch (648:10): [Folded - Ignored] | | ------------------ ------------------ 1089| 14| } 1090| 1.22k| yylval->cpVal = STR_RETURN(); ------------------ | | 786| 1.22k| # define yylval yyg->yylval_r ------------------ yylval->cpVal = STR_RETURN(); ------------------ | | 721| 1.22k| (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 120| 1.22k|#define yyextra yyg->yyextra_r | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 1.22k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 1.22k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 1.22k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 1.22k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 700| 1.22k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 1.22k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ 1091| 1.22k| STACK_POP(); /* ^ after this */ ------------------ | | 677| 1.22k|#define STACK_POP() do { \ | | 678| 1.22k| ap_expr_parser_stack_t *sk; \ | | 679| 1.22k| sk = yyextra->current; \ | | ------------------ | | | | 120| 1.22k|#define yyextra yyg->yyextra_r | | ------------------ | | 680| 1.22k| yyextra->current = sk->next; \ | | ------------------ | | | | 120| 1.22k|#define yyextra yyg->yyextra_r | | ------------------ | | 681| 1.22k| sk->next = yyextra->spares; \ | | ------------------ | | | | 120| 1.22k|#define yyextra yyg->yyextra_r | | ------------------ | | 682| 1.22k| yyextra->spares = sk; \ | | ------------------ | | | | 120| 1.22k|#define yyextra yyg->yyextra_r | | ------------------ | | 683| 1.22k|} while (0) | | ------------------ | | | Branch (683:10): [Folded - Ignored] | | ------------------ ------------------ 1092| 1.22k| return T_STRING; 1093| 1.24k|} 1094| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1095| 122|case YY_STATE_EOF(expr): ------------------ | | 141| 122|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 122|#define YY_END_OF_BUFFER 74 | | ------------------ ------------------ | Branch (1095:1): [True: 122, False: 553k] ------------------ 1096| 122|#line 210 "util_expr_scan.l" 1097| 122|{ 1098| 122| STATE_POP(1); /* */ ------------------ | | 692| 122|#define STATE_POP(sk) do { \ | | 693| 122| if ((sk)) { \ | | ------------------ | | | Branch (693:9): [Folded - Ignored] | | ------------------ | | 694| 122| STACK_POP(); \ | | ------------------ | | | | 677| 122|#define STACK_POP() do { \ | | | | 678| 122| ap_expr_parser_stack_t *sk; \ | | | | 679| 122| sk = yyextra->current; \ | | | | ------------------ | | | | | | 120| 122|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 680| 122| yyextra->current = sk->next; \ | | | | ------------------ | | | | | | 120| 122|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 681| 122| sk->next = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 122|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 682| 122| yyextra->spares = sk; \ | | | | ------------------ | | | | | | 120| 122|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 683| 122|} while (0) | | | | ------------------ | | | | | Branch (683:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 695| 122| } \ | | 696| 122| yy_pop_state(yyscanner); \ | | 697| 122|} while (0) | | ------------------ | | | Branch (697:10): [Folded - Ignored] | | ------------------ ------------------ 1099| 122| if (YY_START != INITIAL) { ------------------ | | 137| 122|#define YY_START ((yyg->yy_start - 1) / 2) ------------------ if (YY_START != INITIAL) { ------------------ | | 725| 122|#define INITIAL 0 ------------------ | Branch (1099:9): [True: 0, False: 122] ------------------ 1100| 0| PERROR("Unterminated expression"); ------------------ | | 645| 0|#define PERROR(msg) do { \ | | 646| 0| yyextra->error2 = msg; \ | | ------------------ | | | | 120| 0|#define yyextra yyg->yyextra_r | | ------------------ | | 647| 0| return T_ERROR; \ | | 648| 0|} while (0) | | ------------------ | | | Branch (648:10): [Folded - Ignored] | | ------------------ ------------------ 1101| 0| } 1102| 122|} 1103| 122| YY_BREAK ------------------ | | 963| 122|#define YY_BREAK /*LINTED*/break; ------------------ 1104| 6.73k|case 1: ------------------ | Branch (1104:1): [True: 6.73k, False: 546k] ------------------ 1105| 6.73k|YY_RULE_SETUP 1106| 6.73k|#line 217 "util_expr_scan.l" 1107| 6.73k|{ 1108| 6.73k| if (yytext[0] == str_stop) { ------------------ | | 122| 6.73k|#define yytext yyg->yytext_r ------------------ if (yytext[0] == str_stop) { ------------------ | | 701| 6.73k|#define str_stop (yyextra->current->scan_stop) | | ------------------ | | | | 120| 6.73k|#define yyextra yyg->yyextra_r | | ------------------ ------------------ | Branch (1108:9): [True: 521, False: 6.21k] ------------------ 1109| 521| if (!STR_EMPTY()) { ------------------ | | 718| 521| (str_ptr == str_buf) | | ------------------ | | | | 699| 521|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 521|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (str_ptr == str_buf) | | ------------------ | | | | 700| 521|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 521|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ | Branch (1109:13): [True: 107, False: 414] ------------------ 1110| 107| yyless(0); /* come back below */ ------------------ | | 184| 107| do \ | | 185| 107| { \ | | 186| 107| /* Undo effects of setting up yytext. */ \ | | 187| 107| int yyless_macro_arg = (n); \ | | 188| 107| YY_LESS_LINENO(yyless_macro_arg);\ | | 189| 107| *yy_cp = yyg->yy_hold_char; \ | | 190| 107| YY_RESTORE_YY_MORE_OFFSET \ | | 191| 107| yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 570| 107|#define YY_MORE_ADJ 0 | | ------------------ | | 192| 107| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 344| 107| yyg->yytext_ptr = yy_bp; \ | | | | ------------------ | | | | | | 333| 107|#define yytext_ptr yytext_r | | | | ------------------ | | | | 345| 107| yyleng = (int) (yy_cp - yy_bp); \ | | | | ------------------ | | | | | | 121| 107|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 346| 107| yyg->yy_hold_char = *yy_cp; \ | | | | 347| 107| *yy_cp = '\0'; \ | | | | 348| 107| yyg->yy_c_buf_p = yy_cp; | | ------------------ | | 193| 107| } \ | | 194| 107| while ( 0 ) | | ------------------ | | | Branch (194:10): [Folded - Ignored] | | ------------------ ------------------ 1111| 107| yylval->cpVal = STR_RETURN(); ------------------ | | 786| 107| # define yylval yyg->yylval_r ------------------ yylval->cpVal = STR_RETURN(); ------------------ | | 721| 107| (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 120| 107|#define yyextra yyg->yyextra_r | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 107|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 107|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 107|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 107|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 700| 107|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 107|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ 1112| 107| return T_STRING; 1113| 107| } 1114| 414| STATE_POP(1); /* */ ------------------ | | 692| 414|#define STATE_POP(sk) do { \ | | 693| 414| if ((sk)) { \ | | ------------------ | | | Branch (693:9): [Folded - Ignored] | | ------------------ | | 694| 414| STACK_POP(); \ | | ------------------ | | | | 677| 414|#define STACK_POP() do { \ | | | | 678| 414| ap_expr_parser_stack_t *sk; \ | | | | 679| 414| sk = yyextra->current; \ | | | | ------------------ | | | | | | 120| 414|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 680| 414| yyextra->current = sk->next; \ | | | | ------------------ | | | | | | 120| 414|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 681| 414| sk->next = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 414|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 682| 414| yyextra->spares = sk; \ | | | | ------------------ | | | | | | 120| 414|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 683| 414|} while (0) | | | | ------------------ | | | | | Branch (683:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 695| 414| } \ | | 696| 414| yy_pop_state(yyscanner); \ | | 697| 414|} while (0) | | ------------------ | | | Branch (697:10): [Folded - Ignored] | | ------------------ ------------------ 1115| 414| return T_STR_END; 1116| 521| } 1117| 6.21k| STR_APPEND_NOCHECK(yytext[0]); ------------------ | | 715| 6.21k| STR_APPEND_CHECK((chr), 0) | | ------------------ | | | | 704| 6.21k|#define STR_APPEND_CHECK(chr, chk) do { \ | | | | 705| 6.21k| if ((chk) && apr_iscntrl((chr))) { \ | | | | ------------------ | | | | | | 210| 0|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (210:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (705:9): [Folded - Ignored] | | | | ------------------ | | | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | | | ------------------ | | | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | | | 651| 0| char *msg; \ | | | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | | | ------------------ | | | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | | | ------------------ | | | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 654| 0| } \ | | | | | | 655| 0| else { \ | | | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 657| 0| } \ | | | | | | 658| 0| PERROR(msg); \ | | | | | | ------------------ | | | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | | | ------------------ | | | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | | | ------------------ | | | | | | | | 647| 0| return T_ERROR; \ | | | | | | | | 648| 0|} while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 659| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (659:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 707| 0| } \ | | | | 708| 6.21k| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 699| 6.21k|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 6.21k|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 6.21k|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 6.21k|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 6.21k|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 6.21k|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | | Branch (708:9): [True: 1, False: 6.21k] | | | | ------------------ | | | | 709| 1| PERROR("String too long"); \ | | | | ------------------ | | | | | | 645| 1|#define PERROR(msg) do { \ | | | | | | 646| 1| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 1|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 1| return T_ERROR; \ | | | | | | 648| 1|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 710| 1| } \ | | | | 711| 6.21k| *str_ptr++ = (char)(chr); \ | | | | ------------------ | | | | | | 699| 6.21k|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 6.21k|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | 712| 6.21k|} while (0) | | | | ------------------ | | | | | Branch (712:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1118| 6.21k|} 1119| 6.21k| YY_BREAK ------------------ | | 963| 6.21k|#define YY_BREAK /*LINTED*/break; ------------------ 1120| |/* regexp backref inside string/arg */ 1121| 21.6k|case 2: ------------------ | Branch (1121:1): [True: 21.6k, False: 531k] ------------------ 1122| 21.6k|YY_RULE_SETUP 1123| 21.6k|#line 231 "util_expr_scan.l" 1124| 21.6k|{ 1125| 21.6k| if (!STR_EMPTY()) { ------------------ | | 718| 21.6k| (str_ptr == str_buf) | | ------------------ | | | | 699| 21.6k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 21.6k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (str_ptr == str_buf) | | ------------------ | | | | 700| 21.6k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 21.6k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ | Branch (1125:9): [True: 10.5k, False: 11.0k] ------------------ 1126| 10.5k| yyless(0); /* come back below */ ------------------ | | 184| 10.5k| do \ | | 185| 10.5k| { \ | | 186| 10.5k| /* Undo effects of setting up yytext. */ \ | | 187| 10.5k| int yyless_macro_arg = (n); \ | | 188| 10.5k| YY_LESS_LINENO(yyless_macro_arg);\ | | 189| 10.5k| *yy_cp = yyg->yy_hold_char; \ | | 190| 10.5k| YY_RESTORE_YY_MORE_OFFSET \ | | 191| 10.5k| yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 570| 10.5k|#define YY_MORE_ADJ 0 | | ------------------ | | 192| 10.5k| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 344| 10.5k| yyg->yytext_ptr = yy_bp; \ | | | | ------------------ | | | | | | 333| 10.5k|#define yytext_ptr yytext_r | | | | ------------------ | | | | 345| 10.5k| yyleng = (int) (yy_cp - yy_bp); \ | | | | ------------------ | | | | | | 121| 10.5k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 346| 10.5k| yyg->yy_hold_char = *yy_cp; \ | | | | 347| 10.5k| *yy_cp = '\0'; \ | | | | 348| 10.5k| yyg->yy_c_buf_p = yy_cp; | | ------------------ | | 193| 10.5k| } \ | | 194| 10.5k| while ( 0 ) | | ------------------ | | | Branch (194:10): [Folded - Ignored] | | ------------------ ------------------ 1127| 10.5k| yylval->cpVal = STR_RETURN(); ------------------ | | 786| 10.5k| # define yylval yyg->yylval_r ------------------ yylval->cpVal = STR_RETURN(); ------------------ | | 721| 10.5k| (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 120| 10.5k|#define yyextra yyg->yyextra_r | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 10.5k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 10.5k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 10.5k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 10.5k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 700| 10.5k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 10.5k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ 1128| 10.5k| return T_STRING; 1129| 10.5k| } 1130| 11.0k| yylval->num = yytext[1] - '0'; ------------------ | | 786| 11.0k| # define yylval yyg->yylval_r ------------------ yylval->num = yytext[1] - '0'; ------------------ | | 122| 11.0k|#define yytext yyg->yytext_r ------------------ 1131| 11.0k| return T_BACKREF; 1132| 21.6k|} 1133| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1134| |/* variable inside string/arg */ 1135| 0|case 3: ------------------ | Branch (1135:1): [True: 0, False: 553k] ------------------ 1136| 0|YY_RULE_SETUP 1137| 0|#line 242 "util_expr_scan.l" 1138| 0|{ 1139| 0| if (!STR_EMPTY()) { ------------------ | | 718| 0| (str_ptr == str_buf) | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (str_ptr == str_buf) | | ------------------ | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ | Branch (1139:9): [True: 0, False: 0] ------------------ 1140| 0| yyless(0); /* come back below */ ------------------ | | 184| 0| do \ | | 185| 0| { \ | | 186| 0| /* Undo effects of setting up yytext. */ \ | | 187| 0| int yyless_macro_arg = (n); \ | | 188| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 189| 0| *yy_cp = yyg->yy_hold_char; \ | | 190| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 191| 0| yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 570| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 192| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 344| 0| yyg->yytext_ptr = yy_bp; \ | | | | ------------------ | | | | | | 333| 0|#define yytext_ptr yytext_r | | | | ------------------ | | | | 345| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | ------------------ | | | | | | 121| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 346| 0| yyg->yy_hold_char = *yy_cp; \ | | | | 347| 0| *yy_cp = '\0'; \ | | | | 348| 0| yyg->yy_c_buf_p = yy_cp; | | ------------------ | | 193| 0| } \ | | 194| 0| while ( 0 ) | | ------------------ | | | Branch (194:10): [Folded - Ignored] | | ------------------ ------------------ 1141| 0| yylval->cpVal = STR_RETURN(); ------------------ | | 786| 0| # define yylval yyg->yylval_r ------------------ yylval->cpVal = STR_RETURN(); ------------------ | | 721| 0| (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 120| 0|#define yyextra yyg->yyextra_r | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ 1142| 0| return T_STRING; 1143| 0| } 1144| 0| STATE_PUSH(var, 1); ------------------ | | 685| 0|#define STATE_PUSH(st, sk) do { \ | | 686| 0| yy_push_state((st), yyscanner); \ | | 687| 0| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 0| STACK_PUSH(); \ | | ------------------ | | | | 661| 0|#define STACK_PUSH() do { \ | | | | 662| 0| ap_expr_parser_stack_t *sk; \ | | | | 663| 0| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 0, False: 0] | | | | ------------------ | | | | 664| 0| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 0| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 0| } \ | | | | 667| 0| else { \ | | | | 668| 0| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 0| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 0|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 0|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 0|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 0| } \ | | | | 670| 0| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 0| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 0| sk->scan_flag = 0; \ | | | | 673| 0| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 0| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 0|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 0| } \ | | 690| 0|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1145| 0| return T_VAR_BEGIN; 1146| 0|} 1147| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1148| 0|case 4: ------------------ | Branch (1148:1): [True: 0, False: 553k] ------------------ 1149| 0|YY_RULE_SETUP 1150| 0|#line 252 "util_expr_scan.l" 1151| 0|{ 1152| 0| if (!STR_EMPTY()) { ------------------ | | 718| 0| (str_ptr == str_buf) | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (str_ptr == str_buf) | | ------------------ | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ | Branch (1152:9): [True: 0, False: 0] ------------------ 1153| 0| yyless(0); /* come back below */ ------------------ | | 184| 0| do \ | | 185| 0| { \ | | 186| 0| /* Undo effects of setting up yytext. */ \ | | 187| 0| int yyless_macro_arg = (n); \ | | 188| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 189| 0| *yy_cp = yyg->yy_hold_char; \ | | 190| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 191| 0| yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 570| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 192| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 344| 0| yyg->yytext_ptr = yy_bp; \ | | | | ------------------ | | | | | | 333| 0|#define yytext_ptr yytext_r | | | | ------------------ | | | | 345| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | ------------------ | | | | | | 121| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 346| 0| yyg->yy_hold_char = *yy_cp; \ | | | | 347| 0| *yy_cp = '\0'; \ | | | | 348| 0| yyg->yy_c_buf_p = yy_cp; | | ------------------ | | 193| 0| } \ | | 194| 0| while ( 0 ) | | ------------------ | | | Branch (194:10): [Folded - Ignored] | | ------------------ ------------------ 1154| 0| yylval->cpVal = STR_RETURN(); ------------------ | | 786| 0| # define yylval yyg->yylval_r ------------------ yylval->cpVal = STR_RETURN(); ------------------ | | 721| 0| (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 120| 0|#define yyextra yyg->yyextra_r | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ 1155| 0| return T_STRING; 1156| 0| } 1157| 0| STATE_PUSH(expr, 1); ------------------ | | 685| 0|#define STATE_PUSH(st, sk) do { \ | | 686| 0| yy_push_state((st), yyscanner); \ | | 687| 0| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 0| STACK_PUSH(); \ | | ------------------ | | | | 661| 0|#define STACK_PUSH() do { \ | | | | 662| 0| ap_expr_parser_stack_t *sk; \ | | | | 663| 0| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 0, False: 0] | | | | ------------------ | | | | 664| 0| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 0| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 0| } \ | | | | 667| 0| else { \ | | | | 668| 0| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 0| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 0|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 0|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 0|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 0| } \ | | | | 670| 0| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 0| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 0| sk->scan_flag = 0; \ | | | | 673| 0| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 0| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 0|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 0| } \ | | 690| 0|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1158| 0| return T_VAREXP_BEGIN; 1159| 0|} 1160| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1161| |/* Any non-octal or octal higher than 377 (decimal 255) is invalid */ 1162| 0|case 5: ------------------ | Branch (1162:1): [True: 0, False: 553k] ------------------ 1163| 0|YY_RULE_SETUP 1164| 0|#line 263 "util_expr_scan.l" 1165| 0|{ 1166| 0| PERROR("Bad character escape sequence"); ------------------ | | 645| 0|#define PERROR(msg) do { \ | | 646| 0| yyextra->error2 = msg; \ | | ------------------ | | | | 120| 0|#define yyextra yyg->yyextra_r | | ------------------ | | 647| 0| return T_ERROR; \ | | 648| 0|} while (0) | | ------------------ | | | Branch (648:10): [Folded - Ignored] | | ------------------ ------------------ 1167| 0|} 1168| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1169| 0|case 6: ------------------ | Branch (1169:1): [True: 0, False: 553k] ------------------ 1170| 0|YY_RULE_SETUP 1171| 0|#line 266 "util_expr_scan.l" 1172| 0|{ 1173| 0| int result; 1174| 0| (void)sscanf(yytext+1, "%o", &result); ------------------ | | 122| 0|#define yytext yyg->yytext_r ------------------ 1175| 0| STR_APPEND_NOCHECK(result); ------------------ | | 715| 0| STR_APPEND_CHECK((chr), 0) | | ------------------ | | | | 704| 0|#define STR_APPEND_CHECK(chr, chk) do { \ | | | | 705| 0| if ((chk) && apr_iscntrl((chr))) { \ | | | | ------------------ | | | | | | 210| 0|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (210:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (705:9): [Folded - Ignored] | | | | ------------------ | | | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | | | ------------------ | | | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | | | 651| 0| char *msg; \ | | | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | | | ------------------ | | | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | | | ------------------ | | | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 654| 0| } \ | | | | | | 655| 0| else { \ | | | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 657| 0| } \ | | | | | | 658| 0| PERROR(msg); \ | | | | | | ------------------ | | | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | | | ------------------ | | | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | | | ------------------ | | | | | | | | 647| 0| return T_ERROR; \ | | | | | | | | 648| 0|} while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 659| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (659:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 707| 0| } \ | | | | 708| 0| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | | Branch (708:9): [True: 0, False: 0] | | | | ------------------ | | | | 709| 0| PERROR("String too long"); \ | | | | ------------------ | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 0| return T_ERROR; \ | | | | | | 648| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 710| 0| } \ | | | | 711| 0| *str_ptr++ = (char)(chr); \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | 712| 0|} while (0) | | | | ------------------ | | | | | Branch (712:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1176| 0|} 1177| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1178| 0|case 7: ------------------ | Branch (1178:1): [True: 0, False: 553k] ------------------ 1179| 0|YY_RULE_SETUP 1180| 0|#line 271 "util_expr_scan.l" 1181| 0|{ 1182| 0| int result; 1183| 0| (void)sscanf(yytext+1, "%x", &result); ------------------ | | 122| 0|#define yytext yyg->yytext_r ------------------ 1184| 0| STR_APPEND_NOCHECK(result); ------------------ | | 715| 0| STR_APPEND_CHECK((chr), 0) | | ------------------ | | | | 704| 0|#define STR_APPEND_CHECK(chr, chk) do { \ | | | | 705| 0| if ((chk) && apr_iscntrl((chr))) { \ | | | | ------------------ | | | | | | 210| 0|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (210:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (705:9): [Folded - Ignored] | | | | ------------------ | | | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | | | ------------------ | | | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | | | 651| 0| char *msg; \ | | | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | | | ------------------ | | | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | | | ------------------ | | | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 654| 0| } \ | | | | | | 655| 0| else { \ | | | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 657| 0| } \ | | | | | | 658| 0| PERROR(msg); \ | | | | | | ------------------ | | | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | | | ------------------ | | | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | | | ------------------ | | | | | | | | 647| 0| return T_ERROR; \ | | | | | | | | 648| 0|} while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 659| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (659:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 707| 0| } \ | | | | 708| 0| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | | Branch (708:9): [True: 0, False: 0] | | | | ------------------ | | | | 709| 0| PERROR("String too long"); \ | | | | ------------------ | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 0| return T_ERROR; \ | | | | | | 648| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 710| 0| } \ | | | | 711| 0| *str_ptr++ = (char)(chr); \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | 712| 0|} while (0) | | | | ------------------ | | | | | Branch (712:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1185| 0|} 1186| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1187| 0|case 8: ------------------ | Branch (1187:1): [True: 0, False: 553k] ------------------ 1188| 0|YY_RULE_SETUP 1189| 0|#line 276 "util_expr_scan.l" 1190| 0|{ STR_APPEND_NOCHECK('\n'); } ------------------ | | 715| 0| STR_APPEND_CHECK((chr), 0) | | ------------------ | | | | 704| 0|#define STR_APPEND_CHECK(chr, chk) do { \ | | | | 705| 0| if ((chk) && apr_iscntrl((chr))) { \ | | | | ------------------ | | | | | | 210| 0|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (210:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (705:9): [Folded - Ignored] | | | | ------------------ | | | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | | | ------------------ | | | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | | | 651| 0| char *msg; \ | | | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | | | ------------------ | | | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | | | ------------------ | | | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 654| 0| } \ | | | | | | 655| 0| else { \ | | | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 657| 0| } \ | | | | | | 658| 0| PERROR(msg); \ | | | | | | ------------------ | | | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | | | ------------------ | | | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | | | ------------------ | | | | | | | | 647| 0| return T_ERROR; \ | | | | | | | | 648| 0|} while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 659| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (659:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 707| 0| } \ | | | | 708| 0| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | | Branch (708:9): [True: 0, False: 0] | | | | ------------------ | | | | 709| 0| PERROR("String too long"); \ | | | | ------------------ | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 0| return T_ERROR; \ | | | | | | 648| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 710| 0| } \ | | | | 711| 0| *str_ptr++ = (char)(chr); \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | 712| 0|} while (0) | | | | ------------------ | | | | | Branch (712:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1191| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1192| 0|case 9: ------------------ | Branch (1192:1): [True: 0, False: 553k] ------------------ 1193| 0|YY_RULE_SETUP 1194| 0|#line 277 "util_expr_scan.l" 1195| 0|{ STR_APPEND_NOCHECK('\r'); } ------------------ | | 715| 0| STR_APPEND_CHECK((chr), 0) | | ------------------ | | | | 704| 0|#define STR_APPEND_CHECK(chr, chk) do { \ | | | | 705| 0| if ((chk) && apr_iscntrl((chr))) { \ | | | | ------------------ | | | | | | 210| 0|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (210:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (705:9): [Folded - Ignored] | | | | ------------------ | | | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | | | ------------------ | | | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | | | 651| 0| char *msg; \ | | | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | | | ------------------ | | | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | | | ------------------ | | | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 654| 0| } \ | | | | | | 655| 0| else { \ | | | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 657| 0| } \ | | | | | | 658| 0| PERROR(msg); \ | | | | | | ------------------ | | | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | | | ------------------ | | | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | | | ------------------ | | | | | | | | 647| 0| return T_ERROR; \ | | | | | | | | 648| 0|} while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 659| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (659:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 707| 0| } \ | | | | 708| 0| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | | Branch (708:9): [True: 0, False: 0] | | | | ------------------ | | | | 709| 0| PERROR("String too long"); \ | | | | ------------------ | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 0| return T_ERROR; \ | | | | | | 648| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 710| 0| } \ | | | | 711| 0| *str_ptr++ = (char)(chr); \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | 712| 0|} while (0) | | | | ------------------ | | | | | Branch (712:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1196| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1197| 0|case 10: ------------------ | Branch (1197:1): [True: 0, False: 553k] ------------------ 1198| 0|YY_RULE_SETUP 1199| 0|#line 278 "util_expr_scan.l" 1200| 0|{ STR_APPEND_NOCHECK('\t'); } ------------------ | | 715| 0| STR_APPEND_CHECK((chr), 0) | | ------------------ | | | | 704| 0|#define STR_APPEND_CHECK(chr, chk) do { \ | | | | 705| 0| if ((chk) && apr_iscntrl((chr))) { \ | | | | ------------------ | | | | | | 210| 0|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (210:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (705:9): [Folded - Ignored] | | | | ------------------ | | | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | | | ------------------ | | | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | | | 651| 0| char *msg; \ | | | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | | | ------------------ | | | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | | | ------------------ | | | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 654| 0| } \ | | | | | | 655| 0| else { \ | | | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 657| 0| } \ | | | | | | 658| 0| PERROR(msg); \ | | | | | | ------------------ | | | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | | | ------------------ | | | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | | | ------------------ | | | | | | | | 647| 0| return T_ERROR; \ | | | | | | | | 648| 0|} while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 659| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (659:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 707| 0| } \ | | | | 708| 0| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | | Branch (708:9): [True: 0, False: 0] | | | | ------------------ | | | | 709| 0| PERROR("String too long"); \ | | | | ------------------ | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 0| return T_ERROR; \ | | | | | | 648| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 710| 0| } \ | | | | 711| 0| *str_ptr++ = (char)(chr); \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | 712| 0|} while (0) | | | | ------------------ | | | | | Branch (712:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1201| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1202| 0|case 11: ------------------ | Branch (1202:1): [True: 0, False: 553k] ------------------ 1203| 0|YY_RULE_SETUP 1204| 0|#line 279 "util_expr_scan.l" 1205| 0|{ STR_APPEND_NOCHECK('\b'); } ------------------ | | 715| 0| STR_APPEND_CHECK((chr), 0) | | ------------------ | | | | 704| 0|#define STR_APPEND_CHECK(chr, chk) do { \ | | | | 705| 0| if ((chk) && apr_iscntrl((chr))) { \ | | | | ------------------ | | | | | | 210| 0|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (210:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (705:9): [Folded - Ignored] | | | | ------------------ | | | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | | | ------------------ | | | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | | | 651| 0| char *msg; \ | | | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | | | ------------------ | | | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | | | ------------------ | | | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 654| 0| } \ | | | | | | 655| 0| else { \ | | | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 657| 0| } \ | | | | | | 658| 0| PERROR(msg); \ | | | | | | ------------------ | | | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | | | ------------------ | | | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | | | ------------------ | | | | | | | | 647| 0| return T_ERROR; \ | | | | | | | | 648| 0|} while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 659| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (659:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 707| 0| } \ | | | | 708| 0| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | | Branch (708:9): [True: 0, False: 0] | | | | ------------------ | | | | 709| 0| PERROR("String too long"); \ | | | | ------------------ | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 0| return T_ERROR; \ | | | | | | 648| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 710| 0| } \ | | | | 711| 0| *str_ptr++ = (char)(chr); \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | 712| 0|} while (0) | | | | ------------------ | | | | | Branch (712:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1206| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1207| 0|case 12: ------------------ | Branch (1207:1): [True: 0, False: 553k] ------------------ 1208| 0|YY_RULE_SETUP 1209| 0|#line 280 "util_expr_scan.l" 1210| 0|{ STR_APPEND_NOCHECK('\f'); } ------------------ | | 715| 0| STR_APPEND_CHECK((chr), 0) | | ------------------ | | | | 704| 0|#define STR_APPEND_CHECK(chr, chk) do { \ | | | | 705| 0| if ((chk) && apr_iscntrl((chr))) { \ | | | | ------------------ | | | | | | 210| 0|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (210:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (705:9): [Folded - Ignored] | | | | ------------------ | | | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | | | ------------------ | | | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | | | 651| 0| char *msg; \ | | | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | | | ------------------ | | | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | | | ------------------ | | | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 654| 0| } \ | | | | | | 655| 0| else { \ | | | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 657| 0| } \ | | | | | | 658| 0| PERROR(msg); \ | | | | | | ------------------ | | | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | | | ------------------ | | | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | | | ------------------ | | | | | | | | 647| 0| return T_ERROR; \ | | | | | | | | 648| 0|} while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 659| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (659:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 707| 0| } \ | | | | 708| 0| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | | Branch (708:9): [True: 0, False: 0] | | | | ------------------ | | | | 709| 0| PERROR("String too long"); \ | | | | ------------------ | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 0| return T_ERROR; \ | | | | | | 648| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 710| 0| } \ | | | | 711| 0| *str_ptr++ = (char)(chr); \ | | | | ------------------ | | | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | 712| 0|} while (0) | | | | ------------------ | | | | | Branch (712:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1211| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1212| 0|case 13: ------------------ | Branch (1212:1): [True: 0, False: 553k] ------------------ 1213| 0|YY_RULE_SETUP 1214| 0|#line 281 "util_expr_scan.l" 1215| 0|{ STR_APPEND_CHECK(yytext[1], 1); } ------------------ | | 704| 0|#define STR_APPEND_CHECK(chr, chk) do { \ | | 705| 0| if ((chk) && apr_iscntrl((chr))) { \ | | ------------------ | | | | 210| 0|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | ------------------ | | | | | Branch (210:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (705:9): [Folded - Ignored] | | ------------------ | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | ------------------ | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | 651| 0| char *msg; \ | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | ------------------ | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 654| 0| } \ | | | | 655| 0| else { \ | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 657| 0| } \ | | | | 658| 0| PERROR(msg); \ | | | | ------------------ | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 0| return T_ERROR; \ | | | | | | 648| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0|} while (0) | | | | ------------------ | | | | | Branch (659:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 707| 0| } \ | | 708| 0| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | | Branch (708:9): [True: 0, False: 0] | | ------------------ | | 709| 0| PERROR("String too long"); \ | | ------------------ | | | | 645| 0|#define PERROR(msg) do { \ | | | | 646| 0| yyextra->error2 = msg; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 647| 0| return T_ERROR; \ | | | | 648| 0|} while (0) | | | | ------------------ | | | | | Branch (648:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 710| 0| } \ | | 711| 0| *str_ptr++ = (char)(chr); \ | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | 712| 0|} while (0) | | ------------------ | | | Branch (712:10): [Folded - Ignored] | | ------------------ ------------------ 1216| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1217| 33|case 14: ------------------ | Branch (1217:1): [True: 33, False: 553k] ------------------ 1218| |/* rule 14 can match eol */ 1219| 33|YY_RULE_SETUP 1220| 33|#line 283 "util_expr_scan.l" 1221| 33|{ 1222| 33| PERROR("Unterminated string or variable"); ------------------ | | 645| 33|#define PERROR(msg) do { \ | | 646| 33| yyextra->error2 = msg; \ | | ------------------ | | | | 120| 33|#define yyextra yyg->yyextra_r | | ------------------ | | 647| 33| return T_ERROR; \ | | 648| 33|} while (0) | | ------------------ | | | Branch (648:10): [Folded - Ignored] | | ------------------ ------------------ 1223| 33|} 1224| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1225| 161k|case 15: ------------------ | Branch (1225:1): [True: 161k, False: 391k] ------------------ 1226| |/* rule 15 can match eol */ 1227| 161k|YY_RULE_SETUP 1228| 161k|#line 287 "util_expr_scan.l" 1229| 161k|{ 1230| 161k| STR_APPEND_CHECK(yytext[0], 1); ------------------ | | 704| 161k|#define STR_APPEND_CHECK(chr, chk) do { \ | | 705| 161k| if ((chk) && apr_iscntrl((chr))) { \ | | ------------------ | | | | 210| 161k|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | ------------------ | | | | | Branch (210:24): [True: 35, False: 161k] | | | | ------------------ | | ------------------ | | | Branch (705:9): [Folded - Ignored] | | ------------------ | | 706| 35| PERROR_CHAR("Invalid string character ", (chr)); \ | | ------------------ | | | | 650| 35|#define PERROR_CHAR(prefix, chr) do { \ | | | | 651| 35| char *msg; \ | | | | 652| 35| if (apr_isprint((chr))) { \ | | | | ------------------ | | | | | | 224| 35|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (224:24): [True: 0, False: 35] | | | | | | ------------------ | | | | ------------------ | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 654| 0| } \ | | | | 655| 35| else { \ | | | | 656| 35| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | ------------------ | | | | | | 120| 35|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 657| 35| } \ | | | | 658| 35| PERROR(msg); \ | | | | ------------------ | | | | | | 645| 35|#define PERROR(msg) do { \ | | | | | | 646| 35| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 35|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 35| return T_ERROR; \ | | | | | | 648| 35|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 659| 35|} while (0) | | | | ------------------ | | | | | Branch (659:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 707| 35| } \ | | 708| 161k| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 699| 161k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 161k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 700| 161k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 161k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 700| 161k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 161k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | | Branch (708:9): [True: 2, False: 161k] | | ------------------ | | 709| 2| PERROR("String too long"); \ | | ------------------ | | | | 645| 2|#define PERROR(msg) do { \ | | | | 646| 2| yyextra->error2 = msg; \ | | | | ------------------ | | | | | | 120| 2|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 647| 2| return T_ERROR; \ | | | | 648| 2|} while (0) | | | | ------------------ | | | | | Branch (648:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 710| 2| } \ | | 711| 161k| *str_ptr++ = (char)(chr); \ | | ------------------ | | | | 699| 161k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 161k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | 712| 161k|} while (0) | | ------------------ | | | Branch (712:10): [Folded - Ignored] | | ------------------ ------------------ 1231| 161k|} 1232| 161k| YY_BREAK ------------------ | | 963| 161k|#define YY_BREAK /*LINTED*/break; ------------------ 1233| 161k|case 16: ------------------ | Branch (1233:1): [True: 6.03k, False: 547k] ------------------ 1234| |/* rule 16 can match eol */ 1235| 6.03k|YY_RULE_SETUP 1236| 6.03k|#line 291 "util_expr_scan.l" 1237| 6.03k|{ 1238| | /* NOP */ 1239| 6.03k|} 1240| 6.03k| YY_BREAK ------------------ | | 963| 6.03k|#define YY_BREAK /*LINTED*/break; ------------------ 1241| 434|case 17: ------------------ | Branch (1241:1): [True: 434, False: 552k] ------------------ 1242| 434|YY_RULE_SETUP 1243| 434|#line 295 "util_expr_scan.l" 1244| 434|{ 1245| 434| STATE_PUSH(str, 1); ------------------ | | 685| 434|#define STATE_PUSH(st, sk) do { \ | | 686| 434| yy_push_state((st), yyscanner); \ | | 687| 434| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 434| STACK_PUSH(); \ | | ------------------ | | | | 661| 434|#define STACK_PUSH() do { \ | | | | 662| 434| ap_expr_parser_stack_t *sk; \ | | | | 663| 434| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 434|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 407, False: 27] | | | | ------------------ | | | | 664| 407| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 407|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 407| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 407|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 407| } \ | | | | 667| 434| else { \ | | | | 668| 27| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 27| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 27|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 27|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 27|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 27| } \ | | | | 670| 434| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 434| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 434| sk->scan_flag = 0; \ | | | | 673| 434| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 434|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 434| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 434|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 434|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 434| } \ | | 690| 434|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1246| 434| str_stop = yytext[0]; ------------------ | | 701| 434|#define str_stop (yyextra->current->scan_stop) | | ------------------ | | | | 120| 434|#define yyextra yyg->yyextra_r | | ------------------ ------------------ str_stop = yytext[0]; ------------------ | | 122| 434|#define yytext yyg->yytext_r ------------------ 1247| 434| return T_STR_BEGIN; 1248| 161k|} 1249| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1250| 0|case 18: ------------------ | Branch (1250:1): [True: 0, False: 553k] ------------------ 1251| 0|YY_RULE_SETUP 1252| 0|#line 301 "util_expr_scan.l" 1253| 0|{ 1254| 0| STATE_PUSH(expr, 1); ------------------ | | 685| 0|#define STATE_PUSH(st, sk) do { \ | | 686| 0| yy_push_state((st), yyscanner); \ | | 687| 0| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 0| STACK_PUSH(); \ | | ------------------ | | | | 661| 0|#define STACK_PUSH() do { \ | | | | 662| 0| ap_expr_parser_stack_t *sk; \ | | | | 663| 0| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 0, False: 0] | | | | ------------------ | | | | 664| 0| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 0| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 0| } \ | | | | 667| 0| else { \ | | | | 668| 0| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 0| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 0|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 0|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 0|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 0| } \ | | | | 670| 0| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 0| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 0| sk->scan_flag = 0; \ | | | | 673| 0| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 0| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 0|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 0| } \ | | 690| 0|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1255| 0| return T_VAREXP_BEGIN; 1256| 161k|} 1257| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1258| 0|case 19: ------------------ | Branch (1258:1): [True: 0, False: 553k] ------------------ 1259| 0|YY_RULE_SETUP 1260| 0|#line 305 "util_expr_scan.l" 1261| 0|{ 1262| 0| STATE_POP(1); /* */ ------------------ | | 692| 0|#define STATE_POP(sk) do { \ | | 693| 0| if ((sk)) { \ | | ------------------ | | | Branch (693:9): [Folded - Ignored] | | ------------------ | | 694| 0| STACK_POP(); \ | | ------------------ | | | | 677| 0|#define STACK_POP() do { \ | | | | 678| 0| ap_expr_parser_stack_t *sk; \ | | | | 679| 0| sk = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 680| 0| yyextra->current = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 681| 0| sk->next = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 682| 0| yyextra->spares = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 683| 0|} while (0) | | | | ------------------ | | | | | Branch (683:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 695| 0| } \ | | 696| 0| yy_pop_state(yyscanner); \ | | 697| 0|} while (0) | | ------------------ | | | Branch (697:10): [Folded - Ignored] | | ------------------ ------------------ 1263| 0| return T_VAREXP_END; 1264| 161k|} 1265| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1266| 0|case 20: ------------------ | Branch (1266:1): [True: 0, False: 553k] ------------------ 1267| 0|YY_RULE_SETUP 1268| 0|#line 311 "util_expr_scan.l" 1269| 0|{ 1270| 0| STATE_PUSH(var, 1); ------------------ | | 685| 0|#define STATE_PUSH(st, sk) do { \ | | 686| 0| yy_push_state((st), yyscanner); \ | | 687| 0| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 0| STACK_PUSH(); \ | | ------------------ | | | | 661| 0|#define STACK_PUSH() do { \ | | | | 662| 0| ap_expr_parser_stack_t *sk; \ | | | | 663| 0| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 0, False: 0] | | | | ------------------ | | | | 664| 0| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 0| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 0| } \ | | | | 667| 0| else { \ | | | | 668| 0| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 0| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 0|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 0|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 0|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 0| } \ | | | | 670| 0| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 0| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 0| sk->scan_flag = 0; \ | | | | 673| 0| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 0| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 0|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 0| } \ | | 690| 0|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1271| 0| return T_VAR_BEGIN; 1272| 161k|} 1273| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1274| 0|case 21: ------------------ | Branch (1274:1): [True: 0, False: 553k] ------------------ 1275| 0|YY_RULE_SETUP 1276| 0|#line 315 "util_expr_scan.l" 1277| 0|{ 1278| 0| yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); ------------------ | | 786| 0| # define yylval yyg->yylval_r ------------------ yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); ------------------ | | 120| 0|#define yyextra yyg->yyextra_r ------------------ yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); ------------------ | | 122| 0|#define yytext yyg->yytext_r ------------------ 1279| 0| return T_ID; 1280| 161k|} 1281| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1282| 0|case 22: ------------------ | Branch (1282:1): [True: 0, False: 553k] ------------------ 1283| 0|YY_RULE_SETUP 1284| 0|#line 319 "util_expr_scan.l" 1285| 0|{ 1286| 0| STATE_PUSH(vararg, 0); ------------------ | | 685| 0|#define STATE_PUSH(st, sk) do { \ | | 686| 0| yy_push_state((st), yyscanner); \ | | 687| 0| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 0| STACK_PUSH(); \ | | ------------------ | | | | 661| 0|#define STACK_PUSH() do { \ | | | | 662| 0| ap_expr_parser_stack_t *sk; \ | | | | 663| 0| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 0, False: 0] | | | | ------------------ | | | | 664| 0| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 0| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 0| } \ | | | | 667| 0| else { \ | | | | 668| 0| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 0| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 0|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 0|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 0|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 0| } \ | | | | 670| 0| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 0| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 0| sk->scan_flag = 0; \ | | | | 673| 0| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 0| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 0|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 0| } \ | | 690| 0|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1287| 0| return yytext[0]; ------------------ | | 122| 0|#define yytext yyg->yytext_r ------------------ 1288| 161k|} 1289| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1290| 0|case 23: ------------------ | Branch (1290:1): [True: 0, False: 553k] ------------------ 1291| 0|YY_RULE_SETUP 1292| 0|#line 323 "util_expr_scan.l" 1293| 0|{ 1294| 0| yyless(0); /* let handle */ ------------------ | | 184| 0| do \ | | 185| 0| { \ | | 186| 0| /* Undo effects of setting up yytext. */ \ | | 187| 0| int yyless_macro_arg = (n); \ | | 188| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 189| 0| *yy_cp = yyg->yy_hold_char; \ | | 190| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 191| 0| yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 570| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 192| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 344| 0| yyg->yytext_ptr = yy_bp; \ | | | | ------------------ | | | | | | 333| 0|#define yytext_ptr yytext_r | | | | ------------------ | | | | 345| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | ------------------ | | | | | | 121| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 346| 0| yyg->yy_hold_char = *yy_cp; \ | | | | 347| 0| *yy_cp = '\0'; \ | | | | 348| 0| yyg->yy_c_buf_p = yy_cp; | | ------------------ | | 193| 0| } \ | | 194| 0| while ( 0 ) | | ------------------ | | | Branch (194:10): [Folded - Ignored] | | ------------------ ------------------ 1295| 0| yylval->cpVal = STR_RETURN(); ------------------ | | 786| 0| # define yylval yyg->yylval_r ------------------ yylval->cpVal = STR_RETURN(); ------------------ | | 721| 0| (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 120| 0|#define yyextra yyg->yyextra_r | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ 1296| 0| STATE_POP(0); /* */ ------------------ | | 692| 0|#define STATE_POP(sk) do { \ | | 693| 0| if ((sk)) { \ | | ------------------ | | | Branch (693:9): [Folded - Ignored] | | ------------------ | | 694| 0| STACK_POP(); \ | | ------------------ | | | | 677| 0|#define STACK_POP() do { \ | | | | 678| 0| ap_expr_parser_stack_t *sk; \ | | | | 679| 0| sk = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 680| 0| yyextra->current = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 681| 0| sk->next = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 682| 0| yyextra->spares = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 683| 0|} while (0) | | | | ------------------ | | | | | Branch (683:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 695| 0| } \ | | 696| 0| yy_pop_state(yyscanner); \ | | 697| 0|} while (0) | | ------------------ | | | Branch (697:10): [Folded - Ignored] | | ------------------ ------------------ 1297| 0| return T_STRING; 1298| 161k|} 1299| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1300| 0|case 24: ------------------ | Branch (1300:1): [True: 0, False: 553k] ------------------ 1301| |/* rule 24 can match eol */ 1302| 0|YY_RULE_SETUP 1303| 0|#line 329 "util_expr_scan.l" 1304| 0|{ 1305| 0| STR_APPEND_CHECK(yytext[0], 1); ------------------ | | 704| 0|#define STR_APPEND_CHECK(chr, chk) do { \ | | 705| 0| if ((chk) && apr_iscntrl((chr))) { \ | | ------------------ | | | | 210| 0|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | ------------------ | | | | | Branch (210:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (705:9): [Folded - Ignored] | | ------------------ | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | ------------------ | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | 651| 0| char *msg; \ | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | ------------------ | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 654| 0| } \ | | | | 655| 0| else { \ | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 657| 0| } \ | | | | 658| 0| PERROR(msg); \ | | | | ------------------ | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 0| return T_ERROR; \ | | | | | | 648| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0|} while (0) | | | | ------------------ | | | | | Branch (659:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 707| 0| } \ | | 708| 0| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 700| 0|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | | Branch (708:9): [True: 0, False: 0] | | ------------------ | | 709| 0| PERROR("String too long"); \ | | ------------------ | | | | 645| 0|#define PERROR(msg) do { \ | | | | 646| 0| yyextra->error2 = msg; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 647| 0| return T_ERROR; \ | | | | 648| 0|} while (0) | | | | ------------------ | | | | | Branch (648:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 710| 0| } \ | | 711| 0| *str_ptr++ = (char)(chr); \ | | ------------------ | | | | 699| 0|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | 712| 0|} while (0) | | ------------------ | | | Branch (712:10): [Folded - Ignored] | | ------------------ ------------------ 1306| 0|} 1307| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1308| 0|case 25: ------------------ | Branch (1308:1): [True: 0, False: 553k] ------------------ 1309| 0|YY_RULE_SETUP 1310| 0|#line 332 "util_expr_scan.l" 1311| 0|{ 1312| 0| STATE_POP(1); /* */ ------------------ | | 692| 0|#define STATE_POP(sk) do { \ | | 693| 0| if ((sk)) { \ | | ------------------ | | | Branch (693:9): [Folded - Ignored] | | ------------------ | | 694| 0| STACK_POP(); \ | | ------------------ | | | | 677| 0|#define STACK_POP() do { \ | | | | 678| 0| ap_expr_parser_stack_t *sk; \ | | | | 679| 0| sk = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 680| 0| yyextra->current = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 681| 0| sk->next = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 682| 0| yyextra->spares = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 683| 0|} while (0) | | | | ------------------ | | | | | Branch (683:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 695| 0| } \ | | 696| 0| yy_pop_state(yyscanner); \ | | 697| 0|} while (0) | | ------------------ | | | Branch (697:10): [Folded - Ignored] | | ------------------ ------------------ 1313| 0| return T_VAR_END; 1314| 0|} 1315| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1316| 0|case 26: ------------------ | Branch (1316:1): [True: 0, False: 553k] ------------------ 1317| |/* rule 26 can match eol */ 1318| 0|YY_RULE_SETUP 1319| 0|#line 336 "util_expr_scan.l" 1320| 0|{ 1321| 0| PERROR_CHAR("Unexpected variable character ", yytext[0]); ------------------ | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | 651| 0| char *msg; \ | | 652| 0| if (apr_isprint((chr))) { \ | | ------------------ | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | ------------------ | | | | | Branch (224:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | ------------------ | | | | 120| 0|#define yyextra yyg->yyextra_r | | ------------------ | | 654| 0| } \ | | 655| 0| else { \ | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | ------------------ | | | | 120| 0|#define yyextra yyg->yyextra_r | | ------------------ | | 657| 0| } \ | | 658| 0| PERROR(msg); \ | | ------------------ | | | | 645| 0|#define PERROR(msg) do { \ | | | | 646| 0| yyextra->error2 = msg; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 647| 0| return T_ERROR; \ | | | | 648| 0|} while (0) | | | | ------------------ | | | | | Branch (648:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 659| 0|} while (0) | | ------------------ | | | Branch (659:10): [Folded - Ignored] | | ------------------ ------------------ 1322| 0|} 1323| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1324| 0|case YY_STATE_EOF(var): ------------------ | | 141| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 0|#define YY_END_OF_BUFFER 74 | | ------------------ ------------------ | Branch (1324:1): [True: 0, False: 553k] ------------------ 1325| 0|case YY_STATE_EOF(vararg): ------------------ | | 141| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 0|#define YY_END_OF_BUFFER 74 | | ------------------ ------------------ | Branch (1325:1): [True: 0, False: 553k] ------------------ 1326| 0|#line 339 "util_expr_scan.l" 1327| 0|{ 1328| 0| PERROR("Unterminated variable"); ------------------ | | 645| 0|#define PERROR(msg) do { \ | | 646| 0| yyextra->error2 = msg; \ | | ------------------ | | | | 120| 0|#define yyextra yyg->yyextra_r | | ------------------ | | 647| 0| return T_ERROR; \ | | 648| 0|} while (0) | | ------------------ | | | Branch (648:10): [Folded - Ignored] | | ------------------ ------------------ 1329| 0|} 1330| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1331| |/* 1332| | * Regular Expression 1333| | */ 1334| 943|case 27: ------------------ | Branch (1334:1): [True: 943, False: 552k] ------------------ 1335| 943|YY_RULE_SETUP 1336| 943|#line 347 "util_expr_scan.l" 1337| 943|{ 1338| 943| STATE_PUSH(regex, 1); ------------------ | | 685| 943|#define STATE_PUSH(st, sk) do { \ | | 686| 943| yy_push_state((st), yyscanner); \ | | 687| 943| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 943| STACK_PUSH(); \ | | ------------------ | | | | 661| 943|#define STACK_PUSH() do { \ | | | | 662| 943| ap_expr_parser_stack_t *sk; \ | | | | 663| 943| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 943|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 928, False: 15] | | | | ------------------ | | | | 664| 928| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 928|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 928| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 928|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 928| } \ | | | | 667| 943| else { \ | | | | 668| 15| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 15| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 15|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 15|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 15|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 15| } \ | | | | 670| 943| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 943| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 943| sk->scan_flag = 0; \ | | | | 673| 943| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 943|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 943| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 943|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 943|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 943| } \ | | 690| 943|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1339| 943| str_stop = yytext[0]; ------------------ | | 701| 943|#define str_stop (yyextra->current->scan_stop) | | ------------------ | | | | 120| 943|#define yyextra yyg->yyextra_r | | ------------------ ------------------ str_stop = yytext[0]; ------------------ | | 122| 943|#define yytext yyg->yytext_r ------------------ 1340| 943| str_flag = 'm'; ------------------ | | 702| 943|#define str_flag (yyextra->current->scan_flag) | | ------------------ | | | | 120| 943|#define yyextra yyg->yyextra_r | | ------------------ ------------------ 1341| 943| return T_REGEX; 1342| 0|} 1343| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1344| 4.83k|case 28: ------------------ | Branch (1344:1): [True: 4.83k, False: 548k] ------------------ 1345| 4.83k|YY_RULE_SETUP 1346| 4.83k|#line 353 "util_expr_scan.l" 1347| 4.83k|{ 1348| 4.83k| STATE_PUSH(regex, 1); ------------------ | | 685| 4.83k|#define STATE_PUSH(st, sk) do { \ | | 686| 4.83k| yy_push_state((st), yyscanner); \ | | 687| 4.83k| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 4.83k| STACK_PUSH(); \ | | ------------------ | | | | 661| 4.83k|#define STACK_PUSH() do { \ | | | | 662| 4.83k| ap_expr_parser_stack_t *sk; \ | | | | 663| 4.83k| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 4.83k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 4.77k, False: 54] | | | | ------------------ | | | | 664| 4.77k| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 4.77k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 4.77k| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 4.77k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 4.77k| } \ | | | | 667| 4.83k| else { \ | | | | 668| 54| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 54| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 54|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 54|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 54|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 54| } \ | | | | 670| 4.83k| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 4.83k| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 4.83k| sk->scan_flag = 0; \ | | | | 673| 4.83k| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 4.83k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 4.83k| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 4.83k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 4.83k|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 4.83k| } \ | | 690| 4.83k|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1349| 4.83k| str_stop = yytext[1]; ------------------ | | 701| 4.83k|#define str_stop (yyextra->current->scan_stop) | | ------------------ | | | | 120| 4.83k|#define yyextra yyg->yyextra_r | | ------------------ ------------------ str_stop = yytext[1]; ------------------ | | 122| 4.83k|#define yytext yyg->yytext_r ------------------ 1350| 4.83k| str_flag = yytext[0]; ------------------ | | 702| 4.83k|#define str_flag (yyextra->current->scan_flag) | | ------------------ | | | | 120| 4.83k|#define yyextra yyg->yyextra_r | | ------------------ ------------------ str_flag = yytext[0]; ------------------ | | 122| 4.83k|#define yytext yyg->yytext_r ------------------ 1351| 4.83k| return (str_flag == 'm') ? T_REGEX : T_REGSUB; ------------------ | | 702| 4.83k|#define str_flag (yyextra->current->scan_flag) | | ------------------ | | | | 120| 4.83k|#define yyextra yyg->yyextra_r | | ------------------ ------------------ | Branch (1351:12): [True: 31, False: 4.80k] ------------------ 1352| 0|} 1353| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1354| 22.9k|case 29: ------------------ | Branch (1354:1): [True: 22.9k, False: 530k] ------------------ 1355| |/* rule 29 can match eol */ 1356| 22.9k|YY_RULE_SETUP 1357| 22.9k|#line 359 "util_expr_scan.l" 1358| 22.9k|{ 1359| 22.9k| if (yytext[0] == str_stop) { ------------------ | | 122| 22.9k|#define yytext yyg->yytext_r ------------------ if (yytext[0] == str_stop) { ------------------ | | 701| 22.9k|#define str_stop (yyextra->current->scan_stop) | | ------------------ | | | | 120| 22.9k|#define yyextra yyg->yyextra_r | | ------------------ ------------------ | Branch (1359:9): [True: 5.77k, False: 17.1k] ------------------ 1360| 5.77k| yylval->cpVal = STR_RETURN(); ------------------ | | 786| 5.77k| # define yylval yyg->yylval_r ------------------ yylval->cpVal = STR_RETURN(); ------------------ | | 721| 5.77k| (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 120| 5.77k|#define yyextra yyg->yyextra_r | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 5.77k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 5.77k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 5.77k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 5.77k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 700| 5.77k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 5.77k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ 1361| 5.77k| STATE_POP(0); /* */ ------------------ | | 692| 5.77k|#define STATE_POP(sk) do { \ | | 693| 5.77k| if ((sk)) { \ | | ------------------ | | | Branch (693:9): [Folded - Ignored] | | ------------------ | | 694| 0| STACK_POP(); \ | | ------------------ | | | | 677| 0|#define STACK_POP() do { \ | | | | 678| 0| ap_expr_parser_stack_t *sk; \ | | | | 679| 0| sk = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 680| 0| yyextra->current = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 681| 0| sk->next = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 682| 0| yyextra->spares = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 683| 0|} while (0) | | | | ------------------ | | | | | Branch (683:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 695| 0| } \ | | 696| 5.77k| yy_pop_state(yyscanner); \ | | 697| 5.77k|} while (0) | | ------------------ | | | Branch (697:10): [Folded - Ignored] | | ------------------ ------------------ 1362| 5.77k| if (str_flag == 'm') { ------------------ | | 702| 5.77k|#define str_flag (yyextra->current->scan_flag) | | ------------------ | | | | 120| 5.77k|#define yyextra yyg->yyextra_r | | ------------------ ------------------ | Branch (1362:13): [True: 972, False: 4.80k] ------------------ 1363| 972| STATE_PUSH(regflags, 0); ------------------ | | 685| 972|#define STATE_PUSH(st, sk) do { \ | | 686| 972| yy_push_state((st), yyscanner); \ | | 687| 972| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 0| STACK_PUSH(); \ | | ------------------ | | | | 661| 0|#define STACK_PUSH() do { \ | | | | 662| 0| ap_expr_parser_stack_t *sk; \ | | | | 663| 0| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 0, False: 0] | | | | ------------------ | | | | 664| 0| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 0| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 0| } \ | | | | 667| 0| else { \ | | | | 668| 0| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 0| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 0|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 0|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 0|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 0| } \ | | | | 670| 0| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 0| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 0| sk->scan_flag = 0; \ | | | | 673| 0| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 0| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 0|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 0| } \ | | 690| 972|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1364| 972| } 1365| 4.80k| else { 1366| 4.80k| STATE_PUSH(regsub, 0); ------------------ | | 685| 4.80k|#define STATE_PUSH(st, sk) do { \ | | 686| 4.80k| yy_push_state((st), yyscanner); \ | | 687| 4.80k| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 0| STACK_PUSH(); \ | | ------------------ | | | | 661| 0|#define STACK_PUSH() do { \ | | | | 662| 0| ap_expr_parser_stack_t *sk; \ | | | | 663| 0| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 0, False: 0] | | | | ------------------ | | | | 664| 0| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 0| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 0| } \ | | | | 667| 0| else { \ | | | | 668| 0| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 0| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 0|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 0|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 0|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 0| } \ | | | | 670| 0| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 0| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 0| sk->scan_flag = 0; \ | | | | 673| 0| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 0| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 0|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 0| } \ | | 690| 4.80k|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1367| 4.80k| } 1368| 5.77k| return T_REG_MATCH; 1369| 5.77k| } 1370| 17.1k| STR_APPEND_CHECK(yytext[0], 1); ------------------ | | 704| 17.1k|#define STR_APPEND_CHECK(chr, chk) do { \ | | 705| 17.1k| if ((chk) && apr_iscntrl((chr))) { \ | | ------------------ | | | | 210| 17.1k|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | ------------------ | | | | | Branch (210:24): [True: 0, False: 17.1k] | | | | ------------------ | | ------------------ | | | Branch (705:9): [Folded - Ignored] | | ------------------ | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | ------------------ | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | 651| 0| char *msg; \ | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | ------------------ | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 654| 0| } \ | | | | 655| 0| else { \ | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 657| 0| } \ | | | | 658| 0| PERROR(msg); \ | | | | ------------------ | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 0| return T_ERROR; \ | | | | | | 648| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0|} while (0) | | | | ------------------ | | | | | Branch (659:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 707| 0| } \ | | 708| 17.1k| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 699| 17.1k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 17.1k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 700| 17.1k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 17.1k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 700| 17.1k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 17.1k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | | Branch (708:9): [True: 2, False: 17.1k] | | ------------------ | | 709| 2| PERROR("String too long"); \ | | ------------------ | | | | 645| 2|#define PERROR(msg) do { \ | | | | 646| 2| yyextra->error2 = msg; \ | | | | ------------------ | | | | | | 120| 2|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 647| 2| return T_ERROR; \ | | | | 648| 2|} while (0) | | | | ------------------ | | | | | Branch (648:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 710| 2| } \ | | 711| 17.1k| *str_ptr++ = (char)(chr); \ | | ------------------ | | | | 699| 17.1k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 17.1k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | 712| 17.1k|} while (0) | | ------------------ | | | Branch (712:10): [Folded - Ignored] | | ------------------ ------------------ 1371| 17.1k|} 1372| 17.1k| YY_BREAK ------------------ | | 963| 17.1k|#define YY_BREAK /*LINTED*/break; ------------------ 1373| 212k|case 30: ------------------ | Branch (1373:1): [True: 212k, False: 341k] ------------------ 1374| |/* rule 30 can match eol */ 1375| 212k|YY_RULE_SETUP 1376| 212k|#line 373 "util_expr_scan.l" 1377| 212k|{ 1378| 212k| if (yytext[0] == str_stop) { ------------------ | | 122| 212k|#define yytext yyg->yytext_r ------------------ if (yytext[0] == str_stop) { ------------------ | | 701| 212k|#define str_stop (yyextra->current->scan_stop) | | ------------------ | | | | 120| 212k|#define yyextra yyg->yyextra_r | | ------------------ ------------------ | Branch (1378:9): [True: 4.79k, False: 207k] ------------------ 1379| 4.79k| yylval->cpVal = STR_RETURN(); ------------------ | | 786| 4.79k| # define yylval yyg->yylval_r ------------------ yylval->cpVal = STR_RETURN(); ------------------ | | 721| 4.79k| (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 120| 4.79k|#define yyextra yyg->yyextra_r | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 4.79k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 4.79k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 4.79k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 4.79k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 700| 4.79k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 4.79k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ 1380| 4.79k| STATE_POP(0); /* */ ------------------ | | 692| 4.79k|#define STATE_POP(sk) do { \ | | 693| 4.79k| if ((sk)) { \ | | ------------------ | | | Branch (693:9): [Folded - Ignored] | | ------------------ | | 694| 0| STACK_POP(); \ | | ------------------ | | | | 677| 0|#define STACK_POP() do { \ | | | | 678| 0| ap_expr_parser_stack_t *sk; \ | | | | 679| 0| sk = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 680| 0| yyextra->current = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 681| 0| sk->next = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 682| 0| yyextra->spares = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 683| 0|} while (0) | | | | ------------------ | | | | | Branch (683:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 695| 0| } \ | | 696| 4.79k| yy_pop_state(yyscanner); \ | | 697| 4.79k|} while (0) | | ------------------ | | | Branch (697:10): [Folded - Ignored] | | ------------------ ------------------ 1381| 4.79k| STATE_PUSH(regflags, 0); ------------------ | | 685| 4.79k|#define STATE_PUSH(st, sk) do { \ | | 686| 4.79k| yy_push_state((st), yyscanner); \ | | 687| 4.79k| if ((sk)) { \ | | ------------------ | | | Branch (687:9): [Folded - Ignored] | | ------------------ | | 688| 0| STACK_PUSH(); \ | | ------------------ | | | | 661| 0|#define STACK_PUSH() do { \ | | | | 662| 0| ap_expr_parser_stack_t *sk; \ | | | | 663| 0| if (yyextra->spares) { \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | | Branch (663:9): [True: 0, False: 0] | | | | ------------------ | | | | 664| 0| sk = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 665| 0| yyextra->spares = sk->next; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 666| 0| } \ | | | | 667| 0| else { \ | | | | 668| 0| sk = apr_palloc(yyextra->ptemp, sizeof(*sk)); \ | | | | ------------------ | | | | | | 425| 0| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | | | | | ------------------ | | | | | | | | 143| 0|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | | | | | ------------------ | | | | | | | | | | 160| 0|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 162| 0|#define APR_STRINGIFY_HELPER(n) #n | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 669| 0| } \ | | | | 670| 0| sk->scan_ptr = sk->scan_buf; \ | | | | 671| 0| sk->scan_stop = sk->scan_buf[0] = '\0'; \ | | | | 672| 0| sk->scan_flag = 0; \ | | | | 673| 0| sk->next = yyextra->current; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 674| 0| yyextra->current = sk; \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 675| 0|} while (0) | | | | ------------------ | | | | | Branch (675:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 0| } \ | | 690| 4.79k|} while (0) | | ------------------ | | | Branch (690:10): [Folded - Ignored] | | ------------------ ------------------ 1382| 4.79k| return T_STRING; 1383| 4.79k| } 1384| 207k| STR_APPEND_CHECK(yytext[0], 1); ------------------ | | 704| 207k|#define STR_APPEND_CHECK(chr, chk) do { \ | | 705| 207k| if ((chk) && apr_iscntrl((chr))) { \ | | ------------------ | | | | 210| 207k|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | ------------------ | | | | | Branch (210:24): [True: 0, False: 207k] | | | | ------------------ | | ------------------ | | | Branch (705:9): [Folded - Ignored] | | ------------------ | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | ------------------ | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | 651| 0| char *msg; \ | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | ------------------ | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 654| 0| } \ | | | | 655| 0| else { \ | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | ------------------ | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 657| 0| } \ | | | | 658| 0| PERROR(msg); \ | | | | ------------------ | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 0| return T_ERROR; \ | | | | | | 648| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0|} while (0) | | | | ------------------ | | | | | Branch (659:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 707| 0| } \ | | 708| 207k| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 699| 207k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 207k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 700| 207k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 207k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | ------------------ | | | | 700| 207k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 207k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | | Branch (708:9): [True: 2, False: 207k] | | ------------------ | | 709| 2| PERROR("String too long"); \ | | ------------------ | | | | 645| 2|#define PERROR(msg) do { \ | | | | 646| 2| yyextra->error2 = msg; \ | | | | ------------------ | | | | | | 120| 2|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 647| 2| return T_ERROR; \ | | | | 648| 2|} while (0) | | | | ------------------ | | | | | Branch (648:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 710| 2| } \ | | 711| 207k| *str_ptr++ = (char)(chr); \ | | ------------------ | | | | 699| 207k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 207k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | 712| 207k|} while (0) | | ------------------ | | | Branch (712:10): [Folded - Ignored] | | ------------------ ------------------ 1385| 207k|} 1386| 207k| YY_BREAK ------------------ | | 963| 207k|#define YY_BREAK /*LINTED*/break; ------------------ 1387| 207k|case 31: ------------------ | Branch (1387:1): [True: 14.7k, False: 538k] ------------------ 1388| |/* rule 31 can match eol */ 1389| 14.7k|YY_RULE_SETUP 1390| 14.7k|#line 382 "util_expr_scan.l" 1391| 14.7k|{ 1392| 14.7k| if (!ap_strchr_c("ismg", yytext[0])) { ------------------ | | 2526| 14.7k|# define ap_strchr_c(s, c) strchr(s, c) ------------------ | Branch (1392:9): [True: 5.75k, False: 8.97k] ------------------ 1393| 5.75k| if (apr_isalnum(yytext[0])) { ------------------ | | 206| 5.75k|#define apr_isalnum(c) (isalnum(((unsigned char)(c)))) | | ------------------ | | | Branch (206:24): [True: 2, False: 5.75k] | | ------------------ ------------------ 1394| 2| PERROR("Invalid regexp flag(s)"); ------------------ | | 645| 2|#define PERROR(msg) do { \ | | 646| 2| yyextra->error2 = msg; \ | | ------------------ | | | | 120| 2|#define yyextra yyg->yyextra_r | | ------------------ | | 647| 2| return T_ERROR; \ | | 648| 2|} while (0) | | ------------------ | | | Branch (648:10): [Folded - Ignored] | | ------------------ ------------------ 1395| 2| } 1396| 5.75k| yyless(0); /* not a flags, rewind */ ------------------ | | 184| 5.75k| do \ | | 185| 5.75k| { \ | | 186| 5.75k| /* Undo effects of setting up yytext. */ \ | | 187| 5.75k| int yyless_macro_arg = (n); \ | | 188| 5.75k| YY_LESS_LINENO(yyless_macro_arg);\ | | 189| 5.75k| *yy_cp = yyg->yy_hold_char; \ | | 190| 5.75k| YY_RESTORE_YY_MORE_OFFSET \ | | 191| 5.75k| yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 570| 5.75k|#define YY_MORE_ADJ 0 | | ------------------ | | 192| 5.75k| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 344| 5.75k| yyg->yytext_ptr = yy_bp; \ | | | | ------------------ | | | | | | 333| 5.75k|#define yytext_ptr yytext_r | | | | ------------------ | | | | 345| 5.75k| yyleng = (int) (yy_cp - yy_bp); \ | | | | ------------------ | | | | | | 121| 5.75k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 346| 5.75k| yyg->yy_hold_char = *yy_cp; \ | | | | 347| 5.75k| *yy_cp = '\0'; \ | | | | 348| 5.75k| yyg->yy_c_buf_p = yy_cp; | | ------------------ | | 193| 5.75k| } \ | | 194| 5.75k| while ( 0 ) | | ------------------ | | | Branch (194:10): [Folded - Ignored] | | ------------------ ------------------ 1397| 5.75k| yylval->cpVal = STR_RETURN(); ------------------ | | 786| 5.75k| # define yylval yyg->yylval_r ------------------ yylval->cpVal = STR_RETURN(); ------------------ | | 721| 5.75k| (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 120| 5.75k|#define yyextra yyg->yyextra_r | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 5.75k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 5.75k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 5.75k|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 5.75k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 700| 5.75k|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 5.75k|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ 1398| 5.75k| STATE_POP(1); /* */ ------------------ | | 692| 5.75k|#define STATE_POP(sk) do { \ | | 693| 5.75k| if ((sk)) { \ | | ------------------ | | | Branch (693:9): [Folded - Ignored] | | ------------------ | | 694| 5.75k| STACK_POP(); \ | | ------------------ | | | | 677| 5.75k|#define STACK_POP() do { \ | | | | 678| 5.75k| ap_expr_parser_stack_t *sk; \ | | | | 679| 5.75k| sk = yyextra->current; \ | | | | ------------------ | | | | | | 120| 5.75k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 680| 5.75k| yyextra->current = sk->next; \ | | | | ------------------ | | | | | | 120| 5.75k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 681| 5.75k| sk->next = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 5.75k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 682| 5.75k| yyextra->spares = sk; \ | | | | ------------------ | | | | | | 120| 5.75k|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 683| 5.75k|} while (0) | | | | ------------------ | | | | | Branch (683:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 695| 5.75k| } \ | | 696| 5.75k| yy_pop_state(yyscanner); \ | | 697| 5.75k|} while (0) | | ------------------ | | | Branch (697:10): [Folded - Ignored] | | ------------------ ------------------ 1399| 5.75k| return T_REG_FLAGS; 1400| 5.75k| } 1401| 8.97k| STR_APPEND_NOCHECK(yytext[0]); ------------------ | | 715| 8.97k| STR_APPEND_CHECK((chr), 0) | | ------------------ | | | | 704| 8.97k|#define STR_APPEND_CHECK(chr, chk) do { \ | | | | 705| 8.97k| if ((chk) && apr_iscntrl((chr))) { \ | | | | ------------------ | | | | | | 210| 0|#define apr_iscntrl(c) (iscntrl(((unsigned char)(c)))) | | | | | | ------------------ | | | | | | | Branch (210:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (705:9): [Folded - Ignored] | | | | ------------------ | | | | 706| 0| PERROR_CHAR("Invalid string character ", (chr)); \ | | | | ------------------ | | | | | | 650| 0|#define PERROR_CHAR(prefix, chr) do { \ | | | | | | 651| 0| char *msg; \ | | | | | | 652| 0| if (apr_isprint((chr))) { \ | | | | | | ------------------ | | | | | | | | 224| 0|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | | | | | ------------------ | | | | | | | | | Branch (224:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 653| 0| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 654| 0| } \ | | | | | | 655| 0| else { \ | | | | | | 656| 0| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | | | | | ------------------ | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 657| 0| } \ | | | | | | 658| 0| PERROR(msg); \ | | | | | | ------------------ | | | | | | | | 645| 0|#define PERROR(msg) do { \ | | | | | | | | 646| 0| yyextra->error2 = msg; \ | | | | | | | | ------------------ | | | | | | | | | | 120| 0|#define yyextra yyg->yyextra_r | | | | | | | | ------------------ | | | | | | | | 647| 0| return T_ERROR; \ | | | | | | | | 648| 0|} while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 659| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (659:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 707| 0| } \ | | | | 708| 8.97k| if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 699| 8.97k|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 8.97k|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 8.97k|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 8.97k|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | if (str_ptr >= str_buf + sizeof(str_buf) - 1) { \ | | | | ------------------ | | | | | | 700| 8.97k|#define str_buf (yyextra->current->scan_buf) | | | | | | ------------------ | | | | | | | | 120| 8.97k|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | | Branch (708:9): [True: 1, False: 8.97k] | | | | ------------------ | | | | 709| 1| PERROR("String too long"); \ | | | | ------------------ | | | | | | 645| 1|#define PERROR(msg) do { \ | | | | | | 646| 1| yyextra->error2 = msg; \ | | | | | | ------------------ | | | | | | | | 120| 1|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | | | 647| 1| return T_ERROR; \ | | | | | | 648| 1|} while (0) | | | | | | ------------------ | | | | | | | Branch (648:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 710| 1| } \ | | | | 711| 8.97k| *str_ptr++ = (char)(chr); \ | | | | ------------------ | | | | | | 699| 8.97k|#define str_ptr (yyextra->current->scan_ptr) | | | | | | ------------------ | | | | | | | | 120| 8.97k|#define yyextra yyg->yyextra_r | | | | | | ------------------ | | | | ------------------ | | | | 712| 8.97k|} while (0) | | | | ------------------ | | | | | Branch (712:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1402| 8.97k|} 1403| 8.97k| YY_BREAK ------------------ | | 963| 8.97k|#define YY_BREAK /*LINTED*/break; ------------------ 1404| 8.97k|case YY_STATE_EOF(regflags): ------------------ | | 141| 15|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 15|#define YY_END_OF_BUFFER 74 | | ------------------ ------------------ | Branch (1404:1): [True: 15, False: 553k] ------------------ 1405| 15|#line 394 "util_expr_scan.l" 1406| 15|{ 1407| 15| yylval->cpVal = STR_RETURN(); ------------------ | | 786| 15| # define yylval yyg->yylval_r ------------------ yylval->cpVal = STR_RETURN(); ------------------ | | 721| 15| (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 120| 15|#define yyextra yyg->yyextra_r | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 15|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 15|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 699| 15|#define str_ptr (yyextra->current->scan_ptr) | | | | ------------------ | | | | | | 120| 15|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ | | (apr_pstrdup(yyextra->pool, (*str_ptr = '\0', str_ptr = str_buf))) | | ------------------ | | | | 700| 15|#define str_buf (yyextra->current->scan_buf) | | | | ------------------ | | | | | | 120| 15|#define yyextra yyg->yyextra_r | | | | ------------------ | | ------------------ ------------------ 1408| 15| STATE_POP(1); /* */ ------------------ | | 692| 15|#define STATE_POP(sk) do { \ | | 693| 15| if ((sk)) { \ | | ------------------ | | | Branch (693:9): [Folded - Ignored] | | ------------------ | | 694| 15| STACK_POP(); \ | | ------------------ | | | | 677| 15|#define STACK_POP() do { \ | | | | 678| 15| ap_expr_parser_stack_t *sk; \ | | | | 679| 15| sk = yyextra->current; \ | | | | ------------------ | | | | | | 120| 15|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 680| 15| yyextra->current = sk->next; \ | | | | ------------------ | | | | | | 120| 15|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 681| 15| sk->next = yyextra->spares; \ | | | | ------------------ | | | | | | 120| 15|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 682| 15| yyextra->spares = sk; \ | | | | ------------------ | | | | | | 120| 15|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 683| 15|} while (0) | | | | ------------------ | | | | | Branch (683:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 695| 15| } \ | | 696| 15| yy_pop_state(yyscanner); \ | | 697| 15|} while (0) | | ------------------ | | | Branch (697:10): [Folded - Ignored] | | ------------------ ------------------ 1409| 15| return T_REG_FLAGS; 1410| 8.97k|} 1411| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1412| 0|case YY_STATE_EOF(regex): ------------------ | | 141| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 0|#define YY_END_OF_BUFFER 74 | | ------------------ ------------------ | Branch (1412:1): [True: 0, False: 553k] ------------------ 1413| 2|case YY_STATE_EOF(regsub): ------------------ | | 141| 2|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 2|#define YY_END_OF_BUFFER 74 | | ------------------ ------------------ | Branch (1413:1): [True: 2, False: 553k] ------------------ 1414| 2|#line 399 "util_expr_scan.l" 1415| 2|{ 1416| 2| PERROR("Unterminated regexp"); ------------------ | | 645| 2|#define PERROR(msg) do { \ | | 646| 2| yyextra->error2 = msg; \ | | ------------------ | | | | 120| 2|#define yyextra yyg->yyextra_r | | ------------------ | | 647| 2| return T_ERROR; \ | | 648| 2|} while (0) | | ------------------ | | | Branch (648:10): [Folded - Ignored] | | ------------------ ------------------ 1417| 2|} 1418| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1419| 1|case 32: ------------------ | Branch (1419:1): [True: 1, False: 553k] ------------------ 1420| 1|YY_RULE_SETUP 1421| 1|#line 403 "util_expr_scan.l" 1422| 1|{ 1423| 1| yylval->num = yytext[1] - '0'; ------------------ | | 786| 1| # define yylval yyg->yylval_r ------------------ yylval->num = yytext[1] - '0'; ------------------ | | 122| 1|#define yytext yyg->yytext_r ------------------ 1424| 1| return T_BACKREF; 1425| 2|} 1426| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1427| |/* 1428| | * Operators 1429| | */ 1430| 128|case 33: ------------------ | Branch (1430:1): [True: 128, False: 553k] ------------------ 1431| 128|YY_RULE_SETUP 1432| 128|#line 411 "util_expr_scan.l" 1433| 128|{ return T_OP_STR_EQ; } 1434| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1435| 0|case 34: ------------------ | Branch (1435:1): [True: 0, False: 553k] ------------------ 1436| 0|YY_RULE_SETUP 1437| 0|#line 412 "util_expr_scan.l" 1438| 0|{ return T_OP_STR_NE; } 1439| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1440| 116|case 35: ------------------ | Branch (1440:1): [True: 116, False: 553k] ------------------ 1441| 116|YY_RULE_SETUP 1442| 116|#line 413 "util_expr_scan.l" 1443| 116|{ return T_OP_STR_LT; } 1444| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1445| 0|case 36: ------------------ | Branch (1445:1): [True: 0, False: 553k] ------------------ 1446| 0|YY_RULE_SETUP 1447| 0|#line 414 "util_expr_scan.l" 1448| 0|{ return T_OP_STR_LE; } 1449| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1450| 44|case 37: ------------------ | Branch (1450:1): [True: 44, False: 553k] ------------------ 1451| 44|YY_RULE_SETUP 1452| 44|#line 415 "util_expr_scan.l" 1453| 44|{ return T_OP_STR_GT; } 1454| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1455| 5|case 38: ------------------ | Branch (1455:1): [True: 5, False: 553k] ------------------ 1456| 5|YY_RULE_SETUP 1457| 5|#line 416 "util_expr_scan.l" 1458| 5|{ return T_OP_STR_GE; } 1459| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1460| 212|case 39: ------------------ | Branch (1460:1): [True: 212, False: 553k] ------------------ 1461| 212|YY_RULE_SETUP 1462| 212|#line 417 "util_expr_scan.l" 1463| 212|{ return T_OP_REG; } 1464| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1465| 129|case 40: ------------------ | Branch (1465:1): [True: 129, False: 553k] ------------------ 1466| 129|YY_RULE_SETUP 1467| 129|#line 418 "util_expr_scan.l" 1468| 129|{ return T_OP_NRE; } 1469| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1470| 0|case 41: ------------------ | Branch (1470:1): [True: 0, False: 553k] ------------------ 1471| 0|YY_RULE_SETUP 1472| 0|#line 419 "util_expr_scan.l" 1473| 0|{ return T_OP_AND; } 1474| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1475| 234|case 42: ------------------ | Branch (1475:1): [True: 234, False: 553k] ------------------ 1476| 234|YY_RULE_SETUP 1477| 234|#line 420 "util_expr_scan.l" 1478| 234|{ return T_OP_AND; } 1479| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1480| 254|case 43: ------------------ | Branch (1480:1): [True: 254, False: 553k] ------------------ 1481| 254|YY_RULE_SETUP 1482| 254|#line 421 "util_expr_scan.l" 1483| 254|{ return T_OP_OR; } 1484| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1485| 1.16k|case 44: ------------------ | Branch (1485:1): [True: 1.16k, False: 552k] ------------------ 1486| 1.16k|YY_RULE_SETUP 1487| 1.16k|#line 422 "util_expr_scan.l" 1488| 1.16k|{ return T_OP_OR; } 1489| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1490| 0|case 45: ------------------ | Branch (1490:1): [True: 0, False: 553k] ------------------ 1491| 0|YY_RULE_SETUP 1492| 0|#line 423 "util_expr_scan.l" 1493| 0|{ return T_OP_NOT; } 1494| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1495| 31.3k|case 46: ------------------ | Branch (1495:1): [True: 31.3k, False: 522k] ------------------ 1496| 31.3k|YY_RULE_SETUP 1497| 31.3k|#line 424 "util_expr_scan.l" 1498| 31.3k|{ return T_OP_NOT; } 1499| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1500| 3.50k|case 47: ------------------ | Branch (1500:1): [True: 3.50k, False: 549k] ------------------ 1501| 3.50k|YY_RULE_SETUP 1502| 3.50k|#line 425 "util_expr_scan.l" 1503| 3.50k|{ return T_OP_CONCAT; } 1504| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1505| 136|case 48: ------------------ | Branch (1505:1): [True: 136, False: 553k] ------------------ 1506| 136|YY_RULE_SETUP 1507| 136|#line 426 "util_expr_scan.l" 1508| 136|{ return T_OP_IN; } 1509| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1510| 0|case 49: ------------------ | Branch (1510:1): [True: 0, False: 553k] ------------------ 1511| 0|YY_RULE_SETUP 1512| 0|#line 427 "util_expr_scan.l" 1513| 0|{ return T_OP_EQ; } 1514| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1515| 0|case 50: ------------------ | Branch (1515:1): [True: 0, False: 553k] ------------------ 1516| 0|YY_RULE_SETUP 1517| 0|#line 428 "util_expr_scan.l" 1518| 0|{ return T_OP_NE; } 1519| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1520| 0|case 51: ------------------ | Branch (1520:1): [True: 0, False: 553k] ------------------ 1521| 0|YY_RULE_SETUP 1522| 0|#line 429 "util_expr_scan.l" 1523| 0|{ return T_OP_GE; } 1524| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1525| 0|case 52: ------------------ | Branch (1525:1): [True: 0, False: 553k] ------------------ 1526| 0|YY_RULE_SETUP 1527| 0|#line 430 "util_expr_scan.l" 1528| 0|{ return T_OP_LE; } 1529| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1530| 0|case 53: ------------------ | Branch (1530:1): [True: 0, False: 553k] ------------------ 1531| 0|YY_RULE_SETUP 1532| 0|#line 431 "util_expr_scan.l" 1533| 0|{ return T_OP_GT; } 1534| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1535| 0|case 54: ------------------ | Branch (1535:1): [True: 0, False: 553k] ------------------ 1536| 0|YY_RULE_SETUP 1537| 0|#line 432 "util_expr_scan.l" 1538| 0|{ return T_OP_LT; } 1539| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1540| |/* for compatibility with ssl_expr */ 1541| 0|case 55: ------------------ | Branch (1541:1): [True: 0, False: 553k] ------------------ 1542| 0|YY_RULE_SETUP 1543| 0|#line 435 "util_expr_scan.l" 1544| 0|{ return T_OP_LT; } 1545| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1546| 0|case 56: ------------------ | Branch (1546:1): [True: 0, False: 553k] ------------------ 1547| 0|YY_RULE_SETUP 1548| 0|#line 436 "util_expr_scan.l" 1549| 0|{ return T_OP_LE; } 1550| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1551| 0|case 57: ------------------ | Branch (1551:1): [True: 0, False: 553k] ------------------ 1552| 0|YY_RULE_SETUP 1553| 0|#line 437 "util_expr_scan.l" 1554| 0|{ return T_OP_GT; } 1555| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1556| 0|case 58: ------------------ | Branch (1556:1): [True: 0, False: 553k] ------------------ 1557| 0|YY_RULE_SETUP 1558| 0|#line 438 "util_expr_scan.l" 1559| 0|{ return T_OP_GE; } 1560| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1561| 0|case 59: ------------------ | Branch (1561:1): [True: 0, False: 553k] ------------------ 1562| 0|YY_RULE_SETUP 1563| 0|#line 439 "util_expr_scan.l" 1564| 0|{ return T_OP_NE; } 1565| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1566| 0|case 60: ------------------ | Branch (1566:1): [True: 0, False: 553k] ------------------ 1567| 0|YY_RULE_SETUP 1568| 0|#line 440 "util_expr_scan.l" 1569| 0|{ return T_OP_EQ; } 1570| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1571| 343|case 61: ------------------ | Branch (1571:1): [True: 343, False: 553k] ------------------ 1572| 343|YY_RULE_SETUP 1573| 343|#line 441 "util_expr_scan.l" 1574| 343|{ return T_OP_IN; } 1575| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1576| 296|case 62: ------------------ | Branch (1576:1): [True: 296, False: 553k] ------------------ 1577| 296|YY_RULE_SETUP 1578| 296|#line 443 "util_expr_scan.l" 1579| 296|{ 1580| 296| yylval->cpVal = apr_pstrdup(yyextra->pool, yytext + 1); ------------------ | | 786| 296| # define yylval yyg->yylval_r ------------------ yylval->cpVal = apr_pstrdup(yyextra->pool, yytext + 1); ------------------ | | 120| 296|#define yyextra yyg->yyextra_r ------------------ yylval->cpVal = apr_pstrdup(yyextra->pool, yytext + 1); ------------------ | | 122| 296|#define yytext yyg->yytext_r ------------------ 1581| 296| return T_OP_BINARY; 1582| 2|} 1583| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1584| 298|case 63: ------------------ | Branch (1584:1): [True: 298, False: 553k] ------------------ 1585| 298|YY_RULE_SETUP 1586| 298|#line 448 "util_expr_scan.l" 1587| 298|{ 1588| 298| yylval->cpVal = apr_pstrdup(yyextra->pool, yytext + 1); ------------------ | | 786| 298| # define yylval yyg->yylval_r ------------------ yylval->cpVal = apr_pstrdup(yyextra->pool, yytext + 1); ------------------ | | 120| 298|#define yyextra yyg->yyextra_r ------------------ yylval->cpVal = apr_pstrdup(yyextra->pool, yytext + 1); ------------------ | | 122| 298|#define yytext yyg->yytext_r ------------------ 1589| 298| return T_OP_UNARY; 1590| 2|} 1591| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1592| |/* Apply subtitution to a string */ 1593| 4.67k|case 64: ------------------ | Branch (1593:1): [True: 4.67k, False: 548k] ------------------ 1594| 4.67k|YY_RULE_SETUP 1595| 4.67k|#line 454 "util_expr_scan.l" 1596| 4.67k|{ 1597| 4.67k| return T_OP_SUB; 1598| 2|} 1599| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1600| |/* Join a list into a string */ 1601| 805|case 65: ------------------ | Branch (1601:1): [True: 805, False: 552k] ------------------ 1602| 805|YY_RULE_SETUP 1603| 805|#line 459 "util_expr_scan.l" 1604| 805|{ 1605| 805| return T_OP_JOIN; 1606| 2|} 1607| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1608| |/* Split a string (or list) into a(nother) list */ 1609| 761|case 66: ------------------ | Branch (1609:1): [True: 761, False: 552k] ------------------ 1610| 761|YY_RULE_SETUP 1611| 761|#line 464 "util_expr_scan.l" 1612| 761|{ 1613| 761| return T_OP_SPLIT; 1614| 2|} 1615| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1616| |/* 1617| | * Specials 1618| | */ 1619| 0|case 67: ------------------ | Branch (1619:1): [True: 0, False: 553k] ------------------ 1620| 0|YY_RULE_SETUP 1621| 0|#line 471 "util_expr_scan.l" 1622| 0|{ return T_TRUE; } 1623| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1624| 0|case 68: ------------------ | Branch (1624:1): [True: 0, False: 553k] ------------------ 1625| 0|YY_RULE_SETUP 1626| 0|#line 472 "util_expr_scan.l" 1627| 0|{ return T_FALSE; } 1628| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1629| |/* 1630| | * Digits 1631| | */ 1632| 7.31k|case 69: ------------------ | Branch (1632:1): [True: 7.31k, False: 546k] ------------------ 1633| 7.31k|YY_RULE_SETUP 1634| 7.31k|#line 477 "util_expr_scan.l" 1635| 7.31k|{ 1636| 7.31k| yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); ------------------ | | 786| 7.31k| # define yylval yyg->yylval_r ------------------ yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); ------------------ | | 120| 7.31k|#define yyextra yyg->yyextra_r ------------------ yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); ------------------ | | 122| 7.31k|#define yytext yyg->yytext_r ------------------ 1637| 7.31k| return T_DIGIT; 1638| 2|} 1639| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1640| |/* 1641| | * Identifiers 1642| | */ 1643| 9.54k|case 70: ------------------ | Branch (1643:1): [True: 9.54k, False: 543k] ------------------ 1644| 9.54k|YY_RULE_SETUP 1645| 9.54k|#line 485 "util_expr_scan.l" 1646| 9.54k|{ 1647| 9.54k| yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); ------------------ | | 786| 9.54k| # define yylval yyg->yylval_r ------------------ yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); ------------------ | | 120| 9.54k|#define yyextra yyg->yyextra_r ------------------ yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); ------------------ | | 122| 9.54k|#define yytext yyg->yytext_r ------------------ 1648| 9.54k| return T_ID; 1649| 2|} 1650| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1651| |/* 1652| | * These are parts of the grammar and are returned as is 1653| | */ 1654| 28.7k|case 71: ------------------ | Branch (1654:1): [True: 28.7k, False: 524k] ------------------ 1655| 28.7k|YY_RULE_SETUP 1656| 28.7k|#line 493 "util_expr_scan.l" 1657| 28.7k|{ 1658| 28.7k| return yytext[0]; ------------------ | | 122| 28.7k|#define yytext yyg->yytext_r ------------------ 1659| 2|} 1660| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1661| |/* 1662| | * Anything else is an error 1663| | */ 1664| 8|case 72: ------------------ | Branch (1664:1): [True: 8, False: 553k] ------------------ 1665| |/* rule 72 can match eol */ 1666| 8|YY_RULE_SETUP 1667| 8|#line 500 "util_expr_scan.l" 1668| 8|{ 1669| 8| PERROR_CHAR("Parse error near character ", yytext[0]); ------------------ | | 650| 8|#define PERROR_CHAR(prefix, chr) do { \ | | 651| 8| char *msg; \ | | 652| 8| if (apr_isprint((chr))) { \ | | ------------------ | | | | 224| 8|#define apr_isprint(c) (isprint(((unsigned char)(c)))) | | | | ------------------ | | | | | Branch (224:24): [True: 6, False: 2] | | | | ------------------ | | ------------------ | | 653| 6| msg = apr_psprintf(yyextra->pool, prefix "'%c'", (char)(chr)); \ | | ------------------ | | | | 120| 6|#define yyextra yyg->yyextra_r | | ------------------ | | 654| 6| } \ | | 655| 8| else { \ | | 656| 2| msg = apr_psprintf(yyextra->pool, prefix "'\\x%.2X'", (int)(chr)); \ | | ------------------ | | | | 120| 2|#define yyextra yyg->yyextra_r | | ------------------ | | 657| 2| } \ | | 658| 8| PERROR(msg); \ | | ------------------ | | | | 645| 8|#define PERROR(msg) do { \ | | | | 646| 8| yyextra->error2 = msg; \ | | | | ------------------ | | | | | | 120| 8|#define yyextra yyg->yyextra_r | | | | ------------------ | | | | 647| 8| return T_ERROR; \ | | | | 648| 8|} while (0) | | | | ------------------ | | | | | Branch (648:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 659| 8|} while (0) | | ------------------ | | | Branch (659:10): [Folded - Ignored] | | ------------------ ------------------ 1670| 8|} 1671| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1672| 0|case 73: ------------------ | Branch (1672:1): [True: 0, False: 553k] ------------------ 1673| 0|YY_RULE_SETUP 1674| 0|#line 504 "util_expr_scan.l" 1675| 0|YY_FATAL_ERROR( "flex scanner jammed" ); ------------------ | | 629| 0| do { \ | | 630| 0| ap_log_error(APLOG_MARK, APLOG_CRIT, 0, ap_server_conf, \ | | ------------------ | | | | 363| 0|#define ap_log_error(...) ap_log_error__(__VA_ARGS__) | | | | ------------------ | | | | | | 366| 0| do { const server_rec *sr__ = s; if (APLOG_MODULE_IS_LEVEL(sr__, mi, level)) \ | | | | | | ------------------ | | | | | | | | 183| 0| ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | | | ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 48| 0|#define APLOG_NOTICE LOG_NOTICE /* normal but significant condition */ | | | | | | | | ------------------ | | | | | | | | | Branch (183:13): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | | | 184| 0| (s == NULL) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (184:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 185| 0| (ap_get_server_module_loglevel(s, module_index) \ | | | | | | | | ------------------ | | | | | | | | | | 629| 0| (ap_get_module_loglevel(&(s)->log,i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 624| 0| (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (624:7): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:8): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:18): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:48): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:67): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 625| 0| (l)->level : \ | | | | | | | | | | | | 626| 0| (l)->module_levels[i]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (626:25): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (185:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 186| 0| >= ((level)&APLOG_LEVELMASK) ) ) | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 367| 0| ap_log_error_(file, line, mi, level, status, sr__, __VA_ARGS__); \ | | | | | | ------------------ | | | | | | | Branch (367:40): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 368| 0| } while(0) | | | | | | ------------------ | | | | | | | Branch (368:13): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 631| 0| APLOGNO(03296) \ | | 632| 0| "expr parser fatal error (BUG?): " \ | | 633| 0| "%s, exiting", msg); \ | | 634| 0| if (unreachable) { \ | | ------------------ | | | Branch (634:13): [True: 0, False: 0] | | ------------------ | | 635| 0| /* Not reached, silence [-Wunused-function] */ \ | | 636| 0| yy_fatal_error(msg, yyscanner); \ | | 637| 0| } \ | | 638| 0| else { \ | | 639| 0| abort(); \ | | 640| 0| } \ | | 641| 0| } while (0) | | ------------------ | | | Branch (641:14): [Folded - Ignored] | | ------------------ ------------------ 1676| 0| YY_BREAK ------------------ | | 963| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1677| 0|#line 1678 "util_expr_scan.c" 1678| 1.34k|case YY_STATE_EOF(INITIAL): ------------------ | | 141| 1.34k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 1.34k|#define YY_END_OF_BUFFER 74 | | ------------------ ------------------ | Branch (1678:1): [True: 1.34k, False: 552k] ------------------ 1679| 1.34k| yyterminate(); ------------------ | | 926| 1.34k|#define yyterminate() return YY_NULL | | ------------------ | | | | 101| 1.34k|#define YY_NULL 0 | | ------------------ ------------------ 1680| | 1681| 8.11k| case YY_END_OF_BUFFER: ------------------ | | 351| 8.11k|#define YY_END_OF_BUFFER 74 ------------------ | Branch (1681:2): [True: 8.11k, False: 545k] ------------------ 1682| 8.11k| { 1683| | /* Amount of text matched not including the EOB char. */ 1684| 8.11k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 333| 8.11k|#define yytext_ptr yytext_r ------------------ 1685| | 1686| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1687| 8.11k| *yy_cp = yyg->yy_hold_char; 1688| 8.11k| YY_RESTORE_YY_MORE_OFFSET 1689| | 1690| 8.11k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 276| 8.11k|#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 ) ------------------ | | 246| 8.11k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1690:8): [True: 2.84k, False: 5.26k] ------------------ 1691| 2.84k| { 1692| | /* We're scanning a new file or input source. It's 1693| | * possible that this happened because the user 1694| | * just pointed yyin at a new source and called 1695| | * ap_expr_yylex(). If so, then we have to assure 1696| | * consistency between YY_CURRENT_BUFFER and our 1697| | * globals. Here is the right place to do so, because 1698| | * this is the first action (other than possibly a 1699| | * back-up) that will match for the new input source. 1700| | */ 1701| 2.84k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 276| 2.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1702| 2.84k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 276| 2.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 118| 2.84k|#define yyin yyg->yyin_r ------------------ 1703| 2.84k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 276| 2.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 247| 2.84k|#define YY_BUFFER_NORMAL 1 ------------------ 1704| 2.84k| } 1705| | 1706| | /* Note that here we test for yy_c_buf_p "<=" to the position 1707| | * of the first EOB in the buffer, since yy_c_buf_p will 1708| | * already have been incremented past the NUL character 1709| | * (since all states make transitions on EOB to the 1710| | * end-of-buffer state). Contrast this with the test 1711| | * in input(). 1712| | */ 1713| 8.11k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 276| 8.11k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1713:8): [True: 0, False: 8.11k] ------------------ 1714| 0| { /* This was really a NUL. */ 1715| 0| yy_state_type yy_next_state; 1716| | 1717| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 333| 0|#define yytext_ptr yytext_r ------------------ 1718| | 1719| 0| yy_current_state = yy_get_previous_state( yyscanner ); 1720| | 1721| | /* Okay, we're now positioned to make the NUL 1722| | * transition. We couldn't have 1723| | * yy_get_previous_state() go ahead and do it 1724| | * for us because it doesn't know how to deal 1725| | * with the possibility of jamming (and we don't 1726| | * want to build jamming into it because then it 1727| | * will run more slowly). 1728| | */ 1729| | 1730| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1731| | 1732| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 570| 0|#define YY_MORE_ADJ 0 ------------------ 1733| | 1734| 0| if ( yy_next_state ) ------------------ | Branch (1734:9): [True: 0, False: 0] ------------------ 1735| 0| { 1736| | /* Consume the NUL. */ 1737| 0| yy_cp = ++yyg->yy_c_buf_p; 1738| 0| yy_current_state = yy_next_state; 1739| 0| goto yy_match; 1740| 0| } 1741| | 1742| 0| else 1743| 0| { 1744| 0| yy_cp = yyg->yy_last_accepting_cpos; 1745| 0| yy_current_state = yyg->yy_last_accepting_state; 1746| 0| goto yy_find_action; 1747| 0| } 1748| 0| } 1749| | 1750| 8.11k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1750:17): [True: 0, False: 8.11k] ------------------ 1751| 8.11k| { 1752| 2.72k| case EOB_ACT_END_OF_FILE: ------------------ | | 176| 2.72k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1752:4): [True: 2.72k, False: 5.38k] ------------------ 1753| 2.72k| { 1754| 2.72k| yyg->yy_did_buffer_switch_on_eof = 0; 1755| | 1756| 2.72k| if ( ap_expr_yywrap(yyscanner ) ) ------------------ | | 326| 2.72k|#define ap_expr_yywrap(yyscanner) (/*CONSTCOND*/1) | | ------------------ | | | Branch (326:35): [Folded - Ignored] | | ------------------ ------------------ 1757| 2.72k| { 1758| | /* Note: because we've taken care in 1759| | * yy_get_next_buffer() to have set up 1760| | * yytext, we can now set up 1761| | * yy_c_buf_p so that if some total 1762| | * hoser (like flex itself) wants to 1763| | * call the scanner after we return the 1764| | * YY_NULL, it'll still work - another 1765| | * YY_NULL will get returned. 1766| | */ 1767| 2.72k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 2.72k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 570| 2.72k|#define YY_MORE_ADJ 0 ------------------ 1768| | 1769| 2.72k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 141| 2.72k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 2.72k|#define YY_END_OF_BUFFER 74 | | ------------------ ------------------ 1770| 2.72k| goto do_action; 1771| 2.72k| } 1772| | 1773| 0| else 1774| 0| { 1775| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (1775:11): [True: 0, False: 0] ------------------ 1776| 0| YY_NEW_FILE; ------------------ | | 144| 0|#define YY_NEW_FILE ap_expr_yyrestart(yyin ,yyscanner ) | | ------------------ | | | | 118| 0|#define yyin yyg->yyin_r | | ------------------ ------------------ 1777| 0| } 1778| 0| break; 1779| 2.72k| } 1780| | 1781| 3.88k| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 175| 3.88k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1781:4): [True: 3.88k, False: 4.23k] ------------------ 1782| 3.88k| yyg->yy_c_buf_p = 1783| 3.88k| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 333| 3.88k|#define yytext_ptr yytext_r ------------------ 1784| | 1785| 3.88k| yy_current_state = yy_get_previous_state( yyscanner ); 1786| | 1787| 3.88k| yy_cp = yyg->yy_c_buf_p; 1788| 3.88k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 3.88k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 570| 3.88k|#define YY_MORE_ADJ 0 ------------------ 1789| 3.88k| goto yy_match; 1790| | 1791| 1.50k| case EOB_ACT_LAST_MATCH: ------------------ | | 177| 1.50k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1791:4): [True: 1.50k, False: 6.60k] ------------------ 1792| 1.50k| yyg->yy_c_buf_p = 1793| 1.50k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 276| 1.50k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1794| | 1795| 1.50k| yy_current_state = yy_get_previous_state( yyscanner ); 1796| | 1797| 1.50k| yy_cp = yyg->yy_c_buf_p; 1798| 1.50k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 1.50k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 570| 1.50k|#define YY_MORE_ADJ 0 ------------------ 1799| 1.50k| goto yy_find_action; 1800| 8.11k| } 1801| 0| break; 1802| 8.11k| } 1803| | 1804| 0| default: ------------------ | Branch (1804:2): [True: 0, False: 553k] ------------------ 1805| 0| YY_FATAL_ERROR( ------------------ | | 629| 0| do { \ | | 630| 0| ap_log_error(APLOG_MARK, APLOG_CRIT, 0, ap_server_conf, \ | | ------------------ | | | | 363| 0|#define ap_log_error(...) ap_log_error__(__VA_ARGS__) | | | | ------------------ | | | | | | 366| 0| do { const server_rec *sr__ = s; if (APLOG_MODULE_IS_LEVEL(sr__, mi, level)) \ | | | | | | ------------------ | | | | | | | | 183| 0| ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | | | ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 48| 0|#define APLOG_NOTICE LOG_NOTICE /* normal but significant condition */ | | | | | | | | ------------------ | | | | | | | | | Branch (183:13): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | | | 184| 0| (s == NULL) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (184:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 185| 0| (ap_get_server_module_loglevel(s, module_index) \ | | | | | | | | ------------------ | | | | | | | | | | 629| 0| (ap_get_module_loglevel(&(s)->log,i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 624| 0| (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (624:7): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:8): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:18): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:48): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:67): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 625| 0| (l)->level : \ | | | | | | | | | | | | 626| 0| (l)->module_levels[i]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (626:25): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (185:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 186| 0| >= ((level)&APLOG_LEVELMASK) ) ) | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 367| 0| ap_log_error_(file, line, mi, level, status, sr__, __VA_ARGS__); \ | | | | | | ------------------ | | | | | | | Branch (367:40): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 368| 0| } while(0) | | | | | | ------------------ | | | | | | | Branch (368:13): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 631| 0| APLOGNO(03296) \ | | 632| 0| "expr parser fatal error (BUG?): " \ | | 633| 0| "%s, exiting", msg); \ | | 634| 0| if (unreachable) { \ | | ------------------ | | | Branch (634:13): [True: 0, False: 0] | | ------------------ | | 635| 0| /* Not reached, silence [-Wunused-function] */ \ | | 636| 0| yy_fatal_error(msg, yyscanner); \ | | 637| 0| } \ | | 638| 0| else { \ | | 639| 0| abort(); \ | | 640| 0| } \ | | 641| 0| } while (0) | | ------------------ | | | Branch (641:14): [Folded - Ignored] | | ------------------ ------------------ 1806| 553k| "fatal flex scanner internal error--no action found" ); 1807| 553k| } /* end of action switch */ 1808| 553k| } /* end of scanning one token */ 1809| 137k| } /* end of user's declarations */ 1810| 137k|} /* end of ap_expr_yylex */ ap_expr_yyrestart: 2097| 2.72k|{ 2098| 2.72k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2099| | 2100| 2.72k| if ( ! YY_CURRENT_BUFFER ){ ------------------ | | 269| 2.72k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 2.72k, False: 0] | | ------------------ | | 270| 2.72k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 2.72k| : NULL) ------------------ | Branch (2100:7): [True: 0, False: 2.72k] ------------------ 2101| 0| ap_expr_yyensure_buffer_stack (yyscanner); 2102| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2103| 0| ap_expr_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); ------------------ | | 118| 0|#define yyin yyg->yyin_r ------------------ ap_expr_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); ------------------ | | 157| 0|#define YY_BUF_SIZE 16384 ------------------ 2104| 0| } 2105| | 2106| 2.72k| ap_expr_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner); ------------------ | | 269| 2.72k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 2.72k, False: 0] | | ------------------ | | 270| 2.72k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 2.72k| : NULL) ------------------ 2107| 2.72k| ap_expr_yy_load_buffer_state(yyscanner ); 2108| 2.72k|} ap_expr_yy_create_buffer: 2162| 1.48k|{ 2163| 1.48k| YY_BUFFER_STATE b; 2164| | 2165| 1.48k| b = (YY_BUFFER_STATE) ap_expr_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); 2166| 1.48k| if ( ! b ) ------------------ | Branch (2166:7): [True: 0, False: 1.48k] ------------------ 2167| 0| YY_FATAL_ERROR( "out of dynamic memory in ap_expr_yy_create_buffer()" ); ------------------ | | 629| 0| do { \ | | 630| 0| ap_log_error(APLOG_MARK, APLOG_CRIT, 0, ap_server_conf, \ | | ------------------ | | | | 363| 0|#define ap_log_error(...) ap_log_error__(__VA_ARGS__) | | | | ------------------ | | | | | | 366| 0| do { const server_rec *sr__ = s; if (APLOG_MODULE_IS_LEVEL(sr__, mi, level)) \ | | | | | | ------------------ | | | | | | | | 183| 0| ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | | | ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 48| 0|#define APLOG_NOTICE LOG_NOTICE /* normal but significant condition */ | | | | | | | | ------------------ | | | | | | | | | Branch (183:13): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | | | 184| 0| (s == NULL) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (184:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 185| 0| (ap_get_server_module_loglevel(s, module_index) \ | | | | | | | | ------------------ | | | | | | | | | | 629| 0| (ap_get_module_loglevel(&(s)->log,i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 624| 0| (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (624:7): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:8): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:18): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:48): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:67): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 625| 0| (l)->level : \ | | | | | | | | | | | | 626| 0| (l)->module_levels[i]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (626:25): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (185:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 186| 0| >= ((level)&APLOG_LEVELMASK) ) ) | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 367| 0| ap_log_error_(file, line, mi, level, status, sr__, __VA_ARGS__); \ | | | | | | ------------------ | | | | | | | Branch (367:40): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 368| 0| } while(0) | | | | | | ------------------ | | | | | | | Branch (368:13): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 631| 0| APLOGNO(03296) \ | | 632| 0| "expr parser fatal error (BUG?): " \ | | 633| 0| "%s, exiting", msg); \ | | 634| 0| if (unreachable) { \ | | ------------------ | | | Branch (634:13): [True: 0, False: 0] | | ------------------ | | 635| 0| /* Not reached, silence [-Wunused-function] */ \ | | 636| 0| yy_fatal_error(msg, yyscanner); \ | | 637| 0| } \ | | 638| 0| else { \ | | 639| 0| abort(); \ | | 640| 0| } \ | | 641| 0| } while (0) | | ------------------ | | | Branch (641:14): [Folded - Ignored] | | ------------------ ------------------ 2168| | 2169| 1.48k| b->yy_buf_size = (yy_size_t)size; 2170| | 2171| | /* yy_ch_buf has to be 2 characters longer than the size given because 2172| | * we need to put in 2 end-of-buffer characters. 2173| | */ 2174| 1.48k| b->yy_ch_buf = (char *) ap_expr_yyalloc(b->yy_buf_size + 2 ,yyscanner ); 2175| 1.48k| if ( ! b->yy_ch_buf ) ------------------ | Branch (2175:7): [True: 0, False: 1.48k] ------------------ 2176| 0| YY_FATAL_ERROR( "out of dynamic memory in ap_expr_yy_create_buffer()" ); ------------------ | | 629| 0| do { \ | | 630| 0| ap_log_error(APLOG_MARK, APLOG_CRIT, 0, ap_server_conf, \ | | ------------------ | | | | 363| 0|#define ap_log_error(...) ap_log_error__(__VA_ARGS__) | | | | ------------------ | | | | | | 366| 0| do { const server_rec *sr__ = s; if (APLOG_MODULE_IS_LEVEL(sr__, mi, level)) \ | | | | | | ------------------ | | | | | | | | 183| 0| ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | | | ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 48| 0|#define APLOG_NOTICE LOG_NOTICE /* normal but significant condition */ | | | | | | | | ------------------ | | | | | | | | | Branch (183:13): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | | | 184| 0| (s == NULL) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (184:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 185| 0| (ap_get_server_module_loglevel(s, module_index) \ | | | | | | | | ------------------ | | | | | | | | | | 629| 0| (ap_get_module_loglevel(&(s)->log,i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 624| 0| (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (624:7): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:8): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:18): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:48): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:67): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 625| 0| (l)->level : \ | | | | | | | | | | | | 626| 0| (l)->module_levels[i]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (626:25): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (185:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 186| 0| >= ((level)&APLOG_LEVELMASK) ) ) | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 367| 0| ap_log_error_(file, line, mi, level, status, sr__, __VA_ARGS__); \ | | | | | | ------------------ | | | | | | | Branch (367:40): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 368| 0| } while(0) | | | | | | ------------------ | | | | | | | Branch (368:13): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 631| 0| APLOGNO(03296) \ | | 632| 0| "expr parser fatal error (BUG?): " \ | | 633| 0| "%s, exiting", msg); \ | | 634| 0| if (unreachable) { \ | | ------------------ | | | Branch (634:13): [True: 0, False: 0] | | ------------------ | | 635| 0| /* Not reached, silence [-Wunused-function] */ \ | | 636| 0| yy_fatal_error(msg, yyscanner); \ | | 637| 0| } \ | | 638| 0| else { \ | | 639| 0| abort(); \ | | 640| 0| } \ | | 641| 0| } while (0) | | ------------------ | | | Branch (641:14): [Folded - Ignored] | | ------------------ ------------------ 2177| | 2178| 1.48k| b->yy_is_our_buffer = 1; 2179| | 2180| 1.48k| ap_expr_yy_init_buffer(b,file ,yyscanner); 2181| | 2182| 1.48k| return b; 2183| 1.48k|} ap_expr_yy_delete_buffer: 2190| 1.48k|{ 2191| 1.48k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2192| | 2193| 1.48k| if ( ! b ) ------------------ | Branch (2193:7): [True: 0, False: 1.48k] ------------------ 2194| 0| return; 2195| | 2196| 1.48k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 269| 1.48k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 1.48k, False: 0] | | ------------------ | | 270| 1.48k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 1.48k| : NULL) ------------------ | Branch (2196:7): [True: 1.48k, False: 0] ------------------ 2197| 1.48k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 276| 1.48k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2198| | 2199| 1.48k| if ( b->yy_is_our_buffer ) ------------------ | Branch (2199:7): [True: 1.48k, False: 0] ------------------ 2200| 1.48k| ap_expr_yyfree((void *) b->yy_ch_buf ,yyscanner ); 2201| | 2202| 1.48k| ap_expr_yyfree((void *) b ,yyscanner ); 2203| 1.48k|} ap_expr_yy_flush_buffer: 2239| 4.21k|{ 2240| 4.21k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2241| 4.21k| if ( ! b ) ------------------ | Branch (2241:7): [True: 0, False: 4.21k] ------------------ 2242| 0| return; 2243| | 2244| 4.21k| b->yy_n_chars = 0; 2245| | 2246| | /* We always need two end-of-buffer characters. The first causes 2247| | * a transition to the end-of-buffer state. The second causes 2248| | * a jam in that state. 2249| | */ 2250| 4.21k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 146| 4.21k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2251| 4.21k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 146| 4.21k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2252| | 2253| 4.21k| b->yy_buf_pos = &b->yy_ch_buf[0]; 2254| | 2255| 4.21k| b->yy_at_bol = 1; 2256| 4.21k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 246| 4.21k|#define YY_BUFFER_NEW 0 ------------------ 2257| | 2258| 4.21k| if ( b == YY_CURRENT_BUFFER ) ------------------ | | 269| 4.21k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 4.21k, False: 0] | | ------------------ | | 270| 4.21k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 4.21k| : NULL) ------------------ | Branch (2258:7): [True: 2.72k, False: 1.48k] ------------------ 2259| 2.72k| ap_expr_yy_load_buffer_state(yyscanner ); 2260| 4.21k|} ap_expr_yypop_buffer_state: 2300| 1.48k|{ 2301| 1.48k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2302| 1.48k| if (!YY_CURRENT_BUFFER) ------------------ | | 269| 1.48k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 1.48k, False: 0] | | ------------------ | | 270| 1.48k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 1.48k| : NULL) ------------------ | Branch (2302:6): [True: 1.48k, False: 0] ------------------ 2303| 1.48k| return; 2304| | 2305| 0| ap_expr_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner); ------------------ | | 269| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 0, False: 0] | | ------------------ | | 270| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 0| : NULL) ------------------ 2306| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2307| 0| if (yyg->yy_buffer_stack_top > 0) ------------------ | Branch (2307:6): [True: 0, False: 0] ------------------ 2308| 0| --yyg->yy_buffer_stack_top; 2309| | 2310| 0| if (YY_CURRENT_BUFFER) { ------------------ | | 269| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:27): [True: 0, False: 0] | | | Branch (269:29): [True: 0, False: 0] | | ------------------ | | 270| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 0| : NULL) ------------------ 2311| 0| ap_expr_yy_load_buffer_state(yyscanner ); 2312| 0| yyg->yy_did_buffer_switch_on_eof = 1; 2313| 0| } 2314| 0|} ap_expr_yyset_extra: 2582| 1.48k|{ 2583| 1.48k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2584| 1.48k| yyextra = user_defined ; ------------------ | | 120| 1.48k|#define yyextra yyg->yyextra_r ------------------ 2585| 1.48k|} ap_expr_yylex_init: 2660| 1.48k|{ 2661| 1.48k| if (ptr_yy_globals == NULL){ ------------------ | Branch (2661:9): [True: 0, False: 1.48k] ------------------ 2662| 0| errno = EINVAL; 2663| 0| return 1; 2664| 0| } 2665| | 2666| 1.48k| *ptr_yy_globals = (yyscan_t) ap_expr_yyalloc ( sizeof( struct yyguts_t ), NULL ); 2667| | 2668| 1.48k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2668:9): [True: 0, False: 1.48k] ------------------ 2669| 0| errno = ENOMEM; 2670| 0| return 1; 2671| 0| } 2672| | 2673| | /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 2674| 1.48k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2675| | 2676| 1.48k| return yy_init_globals ( *ptr_yy_globals ); 2677| 1.48k|} ap_expr_yylex_destroy: 2750| 1.48k|{ 2751| 1.48k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2752| | 2753| | /* Pop the buffer stack, destroying each element. */ 2754| 2.97k| while(YY_CURRENT_BUFFER){ ------------------ | | 269| 2.97k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:27): [True: 1.48k, False: 1.48k] | | | Branch (269:29): [True: 2.97k, False: 0] | | ------------------ | | 270| 2.97k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 2.97k| : NULL) ------------------ 2755| 1.48k| ap_expr_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner ); ------------------ | | 269| 1.48k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 1.48k, False: 0] | | ------------------ | | 270| 1.48k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 1.48k| : NULL) ------------------ 2756| 1.48k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 276| 1.48k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2757| 1.48k| ap_expr_yypop_buffer_state(yyscanner); 2758| 1.48k| } 2759| | 2760| | /* Destroy the stack itself. */ 2761| 1.48k| ap_expr_yyfree(yyg->yy_buffer_stack ,yyscanner); 2762| 1.48k| yyg->yy_buffer_stack = NULL; 2763| | 2764| | /* Destroy the start condition stack. */ 2765| 1.48k| ap_expr_yyfree(yyg->yy_start_stack ,yyscanner ); 2766| 1.48k| yyg->yy_start_stack = NULL; 2767| | 2768| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 2769| | * ap_expr_yylex() is called, initialization will occur. */ 2770| 1.48k| yy_init_globals( yyscanner); 2771| | 2772| | /* Destroy the main struct (reentrant only). */ 2773| 1.48k| ap_expr_yyfree ( yyscanner , yyscanner ); 2774| 1.48k| yyscanner = NULL; 2775| 1.48k| return 0; 2776| 1.48k|} ap_expr_yyalloc: 2806| 7.42k|{ 2807| 7.42k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2808| 7.42k| (void)yyg; 2809| 7.42k| return malloc(size); 2810| 7.42k|} ap_expr_yyrealloc: 2813| 127|{ 2814| 127| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2815| 127| (void)yyg; 2816| | 2817| | /* The cast to (char *) in the following accommodates both 2818| | * implementations that use char* generic pointers, and those 2819| | * that use void* generic pointers. It works with the latter 2820| | * because both ANSI C and C++ allow castless assignment from 2821| | * any pointer type to void*, and deal with argument conversions 2822| | * as though doing an assignment. 2823| | */ 2824| 127| return realloc(ptr, size); 2825| 127|} ap_expr_yyfree: 2828| 7.42k|{ 2829| 7.42k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2830| 7.42k| (void)yyg; 2831| 7.42k| free( (char *) ptr ); /* see ap_expr_yyrealloc() for (char *) cast */ 2832| 7.42k|} util_expr_scan.c:yy_get_next_buffer: 1820| 8.11k|{ 1821| 8.11k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1822| 8.11k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 276| 8.11k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1823| 8.11k| char *source = yyg->yytext_ptr; ------------------ | | 333| 8.11k|#define yytext_ptr yytext_r ------------------ 1824| 8.11k| int number_to_move, i; 1825| 8.11k| int ret_val; 1826| | 1827| 8.11k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 276| 8.11k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1827:7): [True: 0, False: 8.11k] ------------------ 1828| 0| YY_FATAL_ERROR( ------------------ | | 629| 0| do { \ | | 630| 0| ap_log_error(APLOG_MARK, APLOG_CRIT, 0, ap_server_conf, \ | | ------------------ | | | | 363| 0|#define ap_log_error(...) ap_log_error__(__VA_ARGS__) | | | | ------------------ | | | | | | 366| 0| do { const server_rec *sr__ = s; if (APLOG_MODULE_IS_LEVEL(sr__, mi, level)) \ | | | | | | ------------------ | | | | | | | | 183| 0| ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | | | ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 48| 0|#define APLOG_NOTICE LOG_NOTICE /* normal but significant condition */ | | | | | | | | ------------------ | | | | | | | | | Branch (183:13): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | | | 184| 0| (s == NULL) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (184:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 185| 0| (ap_get_server_module_loglevel(s, module_index) \ | | | | | | | | ------------------ | | | | | | | | | | 629| 0| (ap_get_module_loglevel(&(s)->log,i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 624| 0| (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (624:7): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:8): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:18): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:48): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:67): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 625| 0| (l)->level : \ | | | | | | | | | | | | 626| 0| (l)->module_levels[i]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (626:25): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (185:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 186| 0| >= ((level)&APLOG_LEVELMASK) ) ) | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 367| 0| ap_log_error_(file, line, mi, level, status, sr__, __VA_ARGS__); \ | | | | | | ------------------ | | | | | | | Branch (367:40): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 368| 0| } while(0) | | | | | | ------------------ | | | | | | | Branch (368:13): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 631| 0| APLOGNO(03296) \ | | 632| 0| "expr parser fatal error (BUG?): " \ | | 633| 0| "%s, exiting", msg); \ | | 634| 0| if (unreachable) { \ | | ------------------ | | | Branch (634:13): [True: 0, False: 0] | | ------------------ | | 635| 0| /* Not reached, silence [-Wunused-function] */ \ | | 636| 0| yy_fatal_error(msg, yyscanner); \ | | 637| 0| } \ | | 638| 0| else { \ | | 639| 0| abort(); \ | | 640| 0| } \ | | 641| 0| } while (0) | | ------------------ | | | Branch (641:14): [Folded - Ignored] | | ------------------ ------------------ 1829| 8.11k| "fatal flex scanner internal error--end of buffer missed" ); 1830| | 1831| 8.11k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 276| 8.11k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1831:7): [True: 0, False: 8.11k] ------------------ 1832| 0| { /* Don't try to fill the buffer, so this is an EOF. */ 1833| 0| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 333| 0|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 570| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (1833:8): [True: 0, False: 0] ------------------ 1834| 0| { 1835| | /* We matched a single character, the EOB, so 1836| | * treat this as a final EOF. 1837| | */ 1838| 0| return EOB_ACT_END_OF_FILE; ------------------ | | 176| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 1839| 0| } 1840| | 1841| 0| else 1842| 0| { 1843| | /* We matched some text prior to the EOB, first 1844| | * process it. 1845| | */ 1846| 0| return EOB_ACT_LAST_MATCH; ------------------ | | 177| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 1847| 0| } 1848| 0| } 1849| | 1850| | /* Try to read more data. */ 1851| | 1852| | /* First move last chars to start of buffer. */ 1853| 8.11k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 333| 8.11k|#define yytext_ptr yytext_r ------------------ 1854| | 1855| 229M| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (1855:15): [True: 229M, False: 8.11k] ------------------ 1856| 229M| *(dest++) = *(source++); 1857| | 1858| 8.11k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 276| 8.11k|#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 ) ------------------ | | 258| 8.11k|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (1858:7): [True: 1.44k, False: 6.66k] ------------------ 1859| | /* don't do the read, it's not guaranteed to return an EOF, 1860| | * just force an EOF 1861| | */ 1862| 1.44k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 276| 1.44k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1863| | 1864| 6.66k| else 1865| 6.66k| { 1866| 6.66k| int num_to_read = 1867| 6.66k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 276| 6.66k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1868| | 1869| 6.79k| while ( num_to_read <= 0 ) ------------------ | Branch (1869:11): [True: 127, False: 6.66k] ------------------ 1870| 127| { /* Not enough room in the buffer - grow it. */ 1871| | 1872| | /* just a shorter name for the current buffer */ 1873| 127| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 276| 127|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1874| | 1875| 127| int yy_c_buf_p_offset = 1876| 127| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1877| | 1878| 127| if ( b->yy_is_our_buffer ) ------------------ | Branch (1878:9): [True: 127, False: 0] ------------------ 1879| 127| { 1880| 127| int new_size = b->yy_buf_size * 2; 1881| | 1882| 127| if ( new_size <= 0 ) ------------------ | Branch (1882:10): [True: 0, False: 127] ------------------ 1883| 0| b->yy_buf_size += b->yy_buf_size / 8; 1884| 127| else 1885| 127| b->yy_buf_size *= 2; 1886| | 1887| 127| b->yy_ch_buf = (char *) 1888| | /* Include room in for 2 EOB chars. */ 1889| 127| ap_expr_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner ); 1890| 127| } 1891| 0| else 1892| | /* Can't grow it, we don't own it. */ 1893| 0| b->yy_ch_buf = NULL; 1894| | 1895| 127| if ( ! b->yy_ch_buf ) ------------------ | Branch (1895:9): [True: 0, False: 127] ------------------ 1896| 0| YY_FATAL_ERROR( ------------------ | | 629| 0| do { \ | | 630| 0| ap_log_error(APLOG_MARK, APLOG_CRIT, 0, ap_server_conf, \ | | ------------------ | | | | 363| 0|#define ap_log_error(...) ap_log_error__(__VA_ARGS__) | | | | ------------------ | | | | | | 366| 0| do { const server_rec *sr__ = s; if (APLOG_MODULE_IS_LEVEL(sr__, mi, level)) \ | | | | | | ------------------ | | | | | | | | 183| 0| ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | | | ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 48| 0|#define APLOG_NOTICE LOG_NOTICE /* normal but significant condition */ | | | | | | | | ------------------ | | | | | | | | | Branch (183:13): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | | | 184| 0| (s == NULL) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (184:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 185| 0| (ap_get_server_module_loglevel(s, module_index) \ | | | | | | | | ------------------ | | | | | | | | | | 629| 0| (ap_get_module_loglevel(&(s)->log,i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 624| 0| (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (624:7): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:8): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:18): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:48): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:67): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 625| 0| (l)->level : \ | | | | | | | | | | | | 626| 0| (l)->module_levels[i]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (626:25): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (185:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 186| 0| >= ((level)&APLOG_LEVELMASK) ) ) | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 367| 0| ap_log_error_(file, line, mi, level, status, sr__, __VA_ARGS__); \ | | | | | | ------------------ | | | | | | | Branch (367:40): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 368| 0| } while(0) | | | | | | ------------------ | | | | | | | Branch (368:13): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 631| 0| APLOGNO(03296) \ | | 632| 0| "expr parser fatal error (BUG?): " \ | | 633| 0| "%s, exiting", msg); \ | | 634| 0| if (unreachable) { \ | | ------------------ | | | Branch (634:13): [True: 0, False: 0] | | ------------------ | | 635| 0| /* Not reached, silence [-Wunused-function] */ \ | | 636| 0| yy_fatal_error(msg, yyscanner); \ | | 637| 0| } \ | | 638| 0| else { \ | | 639| 0| abort(); \ | | 640| 0| } \ | | 641| 0| } while (0) | | ------------------ | | | Branch (641:14): [Folded - Ignored] | | ------------------ ------------------ 1897| 127| "fatal error - scanner input buffer overflow" ); 1898| | 1899| 127| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1900| | 1901| 127| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 276| 127|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1902| 127| number_to_move - 1; 1903| | 1904| 127| } 1905| | 1906| 6.66k| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 873| 6.66k|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (1906:8): [True: 6.13k, False: 529] ------------------ 1907| 6.13k| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 873| 6.13k|#define YY_READ_BUF_SIZE 8192 ------------------ 1908| | 1909| | /* Read in more data. */ 1910| 6.66k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 608| 6.66k|#define YY_INPUT(buf,result,max_size) \ | | 609| 6.66k|{ \ | | 610| 6.66k| if ((result = MIN(max_size, yyextra->inputbuf \ | | ------------------ | | | | 30| 6.66k|#define MIN(a,b) (((a)<(b))?(a):(b)) | | | | ------------------ | | | | | Branch (30:19): [True: 2.40k, False: 4.25k] | | | | ------------------ | | ------------------ | | | Branch (610:9): [True: 2.78k, False: 3.88k] | | ------------------ | | 611| 6.66k| + yyextra->inputlen \ | | 612| 6.66k| - yyextra->inputptr)) <= 0) \ | | 613| 6.66k| { \ | | 614| 2.78k| result = YY_NULL; \ | | ------------------ | | | | 101| 2.78k|#define YY_NULL 0 | | ------------------ | | 615| 2.78k| } \ | | 616| 6.66k| else { \ | | 617| 3.88k| memcpy(buf, yyextra->inputptr, result); \ | | ------------------ | | | | 120| 3.88k|#define yyextra yyg->yyextra_r | | ------------------ | | 618| 3.88k| yyextra->inputptr += result; \ | | ------------------ | | | | 120| 3.88k|#define yyextra yyg->yyextra_r | | ------------------ | | 619| 3.88k| } \ | | 620| 6.66k|} ------------------ 1911| 6.66k| yyg->yy_n_chars, num_to_read ); 1912| | 1913| 6.66k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 276| 6.66k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1914| 6.66k| } 1915| | 1916| 8.11k| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (1916:7): [True: 4.23k, False: 3.88k] ------------------ 1917| 4.23k| { 1918| 4.23k| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 570| 4.23k|#define YY_MORE_ADJ 0 ------------------ | Branch (1918:8): [True: 2.72k, False: 1.50k] ------------------ 1919| 2.72k| { 1920| 2.72k| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 176| 2.72k|#define EOB_ACT_END_OF_FILE 1 ------------------ 1921| 2.72k| ap_expr_yyrestart(yyin ,yyscanner); ------------------ | | 118| 2.72k|#define yyin yyg->yyin_r ------------------ 1922| 2.72k| } 1923| | 1924| 1.50k| else 1925| 1.50k| { 1926| 1.50k| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 177| 1.50k|#define EOB_ACT_LAST_MATCH 2 ------------------ 1927| 1.50k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 276| 1.50k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1928| 1.50k| YY_BUFFER_EOF_PENDING; ------------------ | | 258| 1.50k|#define YY_BUFFER_EOF_PENDING 2 ------------------ 1929| 1.50k| } 1930| 4.23k| } 1931| | 1932| 3.88k| else 1933| 3.88k| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 175| 3.88k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 1934| | 1935| 8.11k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 276| 8.11k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1935:6): [True: 0, False: 8.11k] ------------------ 1936| | /* Extend the array by 50%, plus the number we really need. */ 1937| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 1938| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) ap_expr_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner ); ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) ap_expr_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner ); ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1939| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1939:8): [True: 0, False: 0] ------------------ 1940| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 629| 0| do { \ | | 630| 0| ap_log_error(APLOG_MARK, APLOG_CRIT, 0, ap_server_conf, \ | | ------------------ | | | | 363| 0|#define ap_log_error(...) ap_log_error__(__VA_ARGS__) | | | | ------------------ | | | | | | 366| 0| do { const server_rec *sr__ = s; if (APLOG_MODULE_IS_LEVEL(sr__, mi, level)) \ | | | | | | ------------------ | | | | | | | | 183| 0| ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | | | ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 48| 0|#define APLOG_NOTICE LOG_NOTICE /* normal but significant condition */ | | | | | | | | ------------------ | | | | | | | | | Branch (183:13): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | | | 184| 0| (s == NULL) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (184:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 185| 0| (ap_get_server_module_loglevel(s, module_index) \ | | | | | | | | ------------------ | | | | | | | | | | 629| 0| (ap_get_module_loglevel(&(s)->log,i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 624| 0| (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (624:7): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:8): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:18): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:48): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:67): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 625| 0| (l)->level : \ | | | | | | | | | | | | 626| 0| (l)->module_levels[i]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (626:25): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (185:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 186| 0| >= ((level)&APLOG_LEVELMASK) ) ) | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 367| 0| ap_log_error_(file, line, mi, level, status, sr__, __VA_ARGS__); \ | | | | | | ------------------ | | | | | | | Branch (367:40): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 368| 0| } while(0) | | | | | | ------------------ | | | | | | | Branch (368:13): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 631| 0| APLOGNO(03296) \ | | 632| 0| "expr parser fatal error (BUG?): " \ | | 633| 0| "%s, exiting", msg); \ | | 634| 0| if (unreachable) { \ | | ------------------ | | | Branch (634:13): [True: 0, False: 0] | | ------------------ | | 635| 0| /* Not reached, silence [-Wunused-function] */ \ | | 636| 0| yy_fatal_error(msg, yyscanner); \ | | 637| 0| } \ | | 638| 0| else { \ | | 639| 0| abort(); \ | | 640| 0| } \ | | 641| 0| } while (0) | | ------------------ | | | Branch (641:14): [Folded - Ignored] | | ------------------ ------------------ 1941| 0| } 1942| | 1943| 8.11k| yyg->yy_n_chars += number_to_move; 1944| 8.11k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 276| 8.11k|#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; ------------------ | | 146| 8.11k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1945| 8.11k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 276| 8.11k|#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; ------------------ | | 146| 8.11k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1946| | 1947| 8.11k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 333| 8.11k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 276| 8.11k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1948| | 1949| 8.11k| return ret_val; 1950| 8.11k|} util_expr_scan.c:yy_get_previous_state: 1955| 5.38k|{ 1956| 5.38k| yy_state_type yy_current_state; 1957| 5.38k| char *yy_cp; 1958| 5.38k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1959| | 1960| 5.38k| yy_current_state = yyg->yy_start; 1961| | 1962| 229M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 333| 5.38k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 570| 5.38k|#define YY_MORE_ADJ 0 ------------------ | Branch (1962:47): [True: 229M, False: 5.38k] ------------------ 1963| 229M| { 1964| 229M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 108| 229M|#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ------------------ | Branch (1964:19): [True: 229M, False: 0] ------------------ 1965| 229M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1965:8): [True: 229M, False: 3.90k] ------------------ 1966| 229M| { 1967| 229M| yyg->yy_last_accepting_state = yy_current_state; 1968| 229M| yyg->yy_last_accepting_cpos = yy_cp; 1969| 229M| } 1970| 429M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1970:11): [True: 200M, False: 229M] ------------------ 1971| 200M| { 1972| 200M| yy_current_state = (int) yy_def[yy_current_state]; 1973| 200M| if ( yy_current_state >= 155 ) ------------------ | Branch (1973:9): [True: 200M, False: 1.26k] ------------------ 1974| 200M| yy_c = yy_meta[(unsigned int) yy_c]; 1975| 200M| } 1976| 229M| yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; 1977| 229M| } 1978| | 1979| 5.38k| return yy_current_state; 1980| 5.38k|} util_expr_scan.c:ap_expr_yy_load_buffer_state: 2147| 6.93k|{ 2148| 6.93k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2149| 6.93k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 276| 6.93k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2150| 6.93k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 333| 6.93k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 276| 6.93k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2151| 6.93k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 118| 6.93k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 276| 6.93k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2152| 6.93k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 2153| 6.93k|} util_expr_scan.c:ap_expr_yy_init_buffer: 2211| 4.21k|{ 2212| 4.21k| int oerrno = errno; 2213| 4.21k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2214| | 2215| 4.21k| ap_expr_yy_flush_buffer(b ,yyscanner); 2216| | 2217| 4.21k| b->yy_input_file = file; 2218| 4.21k| b->yy_fill_buffer = 1; 2219| | 2220| | /* If b is the current buffer, then ap_expr_yy_init_buffer was _probably_ 2221| | * called from ap_expr_yyrestart() or through yy_get_next_buffer. 2222| | * In that case, we don't want to reset the lineno or column. 2223| | */ 2224| 4.21k| if (b != YY_CURRENT_BUFFER){ ------------------ | | 269| 4.21k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 4.21k, False: 0] | | ------------------ | | 270| 4.21k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 4.21k| : NULL) ------------------ | Branch (2224:9): [True: 1.48k, False: 2.72k] ------------------ 2225| 1.48k| b->yy_bs_lineno = 1; 2226| 1.48k| b->yy_bs_column = 0; 2227| 1.48k| } 2228| | 2229| 4.21k| b->yy_is_interactive = 0; 2230| | 2231| 4.21k| errno = oerrno; 2232| 4.21k|} util_expr_scan.c:ap_expr_yyensure_buffer_stack: 2320| 1.48k|{ 2321| 1.48k| int num_to_alloc; 2322| 1.48k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2323| | 2324| 1.48k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2324:6): [True: 1.48k, False: 0] ------------------ 2325| | 2326| | /* First allocation is just for 2 elements, since we don't know if this 2327| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 2328| | * immediate realloc on the next call. 2329| | */ 2330| 1.48k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2331| 1.48k| yyg->yy_buffer_stack = (struct yy_buffer_state**)ap_expr_yyalloc 2332| 1.48k| (num_to_alloc * sizeof(struct yy_buffer_state*) 2333| 1.48k| , yyscanner); 2334| 1.48k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2334:8): [True: 0, False: 1.48k] ------------------ 2335| 0| YY_FATAL_ERROR( "out of dynamic memory in ap_expr_yyensure_buffer_stack()" ); ------------------ | | 629| 0| do { \ | | 630| 0| ap_log_error(APLOG_MARK, APLOG_CRIT, 0, ap_server_conf, \ | | ------------------ | | | | 363| 0|#define ap_log_error(...) ap_log_error__(__VA_ARGS__) | | | | ------------------ | | | | | | 366| 0| do { const server_rec *sr__ = s; if (APLOG_MODULE_IS_LEVEL(sr__, mi, level)) \ | | | | | | ------------------ | | | | | | | | 183| 0| ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | | | ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 48| 0|#define APLOG_NOTICE LOG_NOTICE /* normal but significant condition */ | | | | | | | | ------------------ | | | | | | | | | Branch (183:13): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | | | 184| 0| (s == NULL) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (184:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 185| 0| (ap_get_server_module_loglevel(s, module_index) \ | | | | | | | | ------------------ | | | | | | | | | | 629| 0| (ap_get_module_loglevel(&(s)->log,i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 624| 0| (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (624:7): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:8): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:18): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:48): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:67): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 625| 0| (l)->level : \ | | | | | | | | | | | | 626| 0| (l)->module_levels[i]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (626:25): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (185:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 186| 0| >= ((level)&APLOG_LEVELMASK) ) ) | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 367| 0| ap_log_error_(file, line, mi, level, status, sr__, __VA_ARGS__); \ | | | | | | ------------------ | | | | | | | Branch (367:40): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 368| 0| } while(0) | | | | | | ------------------ | | | | | | | Branch (368:13): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 631| 0| APLOGNO(03296) \ | | 632| 0| "expr parser fatal error (BUG?): " \ | | 633| 0| "%s, exiting", msg); \ | | 634| 0| if (unreachable) { \ | | ------------------ | | | Branch (634:13): [True: 0, False: 0] | | ------------------ | | 635| 0| /* Not reached, silence [-Wunused-function] */ \ | | 636| 0| yy_fatal_error(msg, yyscanner); \ | | 637| 0| } \ | | 638| 0| else { \ | | 639| 0| abort(); \ | | 640| 0| } \ | | 641| 0| } while (0) | | ------------------ | | | Branch (641:14): [Folded - Ignored] | | ------------------ ------------------ 2336| | 2337| 1.48k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2338| | 2339| 1.48k| yyg->yy_buffer_stack_max = num_to_alloc; 2340| 1.48k| yyg->yy_buffer_stack_top = 0; 2341| 1.48k| return; 2342| 1.48k| } 2343| | 2344| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (2344:6): [True: 0, False: 0] ------------------ 2345| | 2346| | /* Increase the buffer to prepare for a possible push. */ 2347| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 2348| | 2349| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 2350| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)ap_expr_yyrealloc 2351| 0| (yyg->yy_buffer_stack, 2352| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 2353| 0| , yyscanner); 2354| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2354:8): [True: 0, False: 0] ------------------ 2355| 0| YY_FATAL_ERROR( "out of dynamic memory in ap_expr_yyensure_buffer_stack()" ); ------------------ | | 629| 0| do { \ | | 630| 0| ap_log_error(APLOG_MARK, APLOG_CRIT, 0, ap_server_conf, \ | | ------------------ | | | | 363| 0|#define ap_log_error(...) ap_log_error__(__VA_ARGS__) | | | | ------------------ | | | | | | 366| 0| do { const server_rec *sr__ = s; if (APLOG_MODULE_IS_LEVEL(sr__, mi, level)) \ | | | | | | ------------------ | | | | | | | | 183| 0| ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | | | ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 48| 0|#define APLOG_NOTICE LOG_NOTICE /* normal but significant condition */ | | | | | | | | ------------------ | | | | | | | | | Branch (183:13): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | | | 184| 0| (s == NULL) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (184:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 185| 0| (ap_get_server_module_loglevel(s, module_index) \ | | | | | | | | ------------------ | | | | | | | | | | 629| 0| (ap_get_module_loglevel(&(s)->log,i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 624| 0| (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (624:7): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:8): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:18): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:48): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:67): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 625| 0| (l)->level : \ | | | | | | | | | | | | 626| 0| (l)->module_levels[i]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (626:25): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (185:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 186| 0| >= ((level)&APLOG_LEVELMASK) ) ) | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 367| 0| ap_log_error_(file, line, mi, level, status, sr__, __VA_ARGS__); \ | | | | | | ------------------ | | | | | | | Branch (367:40): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 368| 0| } while(0) | | | | | | ------------------ | | | | | | | Branch (368:13): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 631| 0| APLOGNO(03296) \ | | 632| 0| "expr parser fatal error (BUG?): " \ | | 633| 0| "%s, exiting", msg); \ | | 634| 0| if (unreachable) { \ | | ------------------ | | | Branch (634:13): [True: 0, False: 0] | | ------------------ | | 635| 0| /* Not reached, silence [-Wunused-function] */ \ | | 636| 0| yy_fatal_error(msg, yyscanner); \ | | 637| 0| } \ | | 638| 0| else { \ | | 639| 0| abort(); \ | | 640| 0| } \ | | 641| 0| } while (0) | | ------------------ | | | Branch (641:14): [Folded - Ignored] | | ------------------ ------------------ 2356| | 2357| | /* zero only the new slots.*/ 2358| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 2359| 0| yyg->yy_buffer_stack_max = num_to_alloc; 2360| 0| } 2361| 0|} util_expr_scan.c:yy_push_state: 2450| 18.2k|{ 2451| 18.2k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2452| 18.2k| if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth ) ------------------ | Branch (2452:7): [True: 1.48k, False: 16.7k] ------------------ 2453| 1.48k| { 2454| 1.48k| yy_size_t new_size; 2455| | 2456| 1.48k| yyg->yy_start_stack_depth += YY_START_STACK_INCR; ------------------ | | 931| 1.48k|#define YY_START_STACK_INCR 25 ------------------ 2457| 1.48k| new_size = (yy_size_t) yyg->yy_start_stack_depth * sizeof( int ); 2458| | 2459| 1.48k| if ( ! yyg->yy_start_stack ) ------------------ | Branch (2459:8): [True: 1.48k, False: 0] ------------------ 2460| 1.48k| yyg->yy_start_stack = (int *) ap_expr_yyalloc(new_size ,yyscanner ); 2461| | 2462| 0| else 2463| 0| yyg->yy_start_stack = (int *) ap_expr_yyrealloc((void *) yyg->yy_start_stack,new_size ,yyscanner ); 2464| | 2465| 1.48k| if ( ! yyg->yy_start_stack ) ------------------ | Branch (2465:8): [True: 0, False: 1.48k] ------------------ 2466| 0| YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); ------------------ | | 629| 0| do { \ | | 630| 0| ap_log_error(APLOG_MARK, APLOG_CRIT, 0, ap_server_conf, \ | | ------------------ | | | | 363| 0|#define ap_log_error(...) ap_log_error__(__VA_ARGS__) | | | | ------------------ | | | | | | 366| 0| do { const server_rec *sr__ = s; if (APLOG_MODULE_IS_LEVEL(sr__, mi, level)) \ | | | | | | ------------------ | | | | | | | | 183| 0| ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | | | ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 48| 0|#define APLOG_NOTICE LOG_NOTICE /* normal but significant condition */ | | | | | | | | ------------------ | | | | | | | | | Branch (183:13): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | | | 184| 0| (s == NULL) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (184:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 185| 0| (ap_get_server_module_loglevel(s, module_index) \ | | | | | | | | ------------------ | | | | | | | | | | 629| 0| (ap_get_module_loglevel(&(s)->log,i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 624| 0| (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (624:7): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:8): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:18): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:48): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:67): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 625| 0| (l)->level : \ | | | | | | | | | | | | 626| 0| (l)->module_levels[i]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (626:25): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (185:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 186| 0| >= ((level)&APLOG_LEVELMASK) ) ) | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 367| 0| ap_log_error_(file, line, mi, level, status, sr__, __VA_ARGS__); \ | | | | | | ------------------ | | | | | | | Branch (367:40): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 368| 0| } while(0) | | | | | | ------------------ | | | | | | | Branch (368:13): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 631| 0| APLOGNO(03296) \ | | 632| 0| "expr parser fatal error (BUG?): " \ | | 633| 0| "%s, exiting", msg); \ | | 634| 0| if (unreachable) { \ | | ------------------ | | | Branch (634:13): [True: 0, False: 0] | | ------------------ | | 635| 0| /* Not reached, silence [-Wunused-function] */ \ | | 636| 0| yy_fatal_error(msg, yyscanner); \ | | 637| 0| } \ | | 638| 0| else { \ | | 639| 0| abort(); \ | | 640| 0| } \ | | 641| 0| } while (0) | | ------------------ | | | Branch (641:14): [Folded - Ignored] | | ------------------ ------------------ 2467| 1.48k| } 2468| | 2469| 18.2k| yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START; ------------------ | | 137| 18.2k|#define YY_START ((yyg->yy_start - 1) / 2) ------------------ 2470| | 2471| 18.2k| BEGIN(_new_state); ------------------ | | 131| 18.2k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ 2472| 18.2k|} util_expr_scan.c:yy_pop_state: 2475| 18.1k|{ 2476| 18.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2477| 18.1k| if ( --yyg->yy_start_stack_ptr < 0 ) ------------------ | Branch (2477:7): [True: 0, False: 18.1k] ------------------ 2478| 0| YY_FATAL_ERROR( "start-condition stack underflow" ); ------------------ | | 629| 0| do { \ | | 630| 0| ap_log_error(APLOG_MARK, APLOG_CRIT, 0, ap_server_conf, \ | | ------------------ | | | | 363| 0|#define ap_log_error(...) ap_log_error__(__VA_ARGS__) | | | | ------------------ | | | | | | 366| 0| do { const server_rec *sr__ = s; if (APLOG_MODULE_IS_LEVEL(sr__, mi, level)) \ | | | | | | ------------------ | | | | | | | | 183| 0| ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | | | ( (((level)&APLOG_LEVELMASK) <= APLOG_NOTICE) || \ | | | | | | | | ------------------ | | | | | | | | | | 48| 0|#define APLOG_NOTICE LOG_NOTICE /* normal but significant condition */ | | | | | | | | ------------------ | | | | | | | | | Branch (183:13): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | | | 184| 0| (s == NULL) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (184:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 185| 0| (ap_get_server_module_loglevel(s, module_index) \ | | | | | | | | ------------------ | | | | | | | | | | 629| 0| (ap_get_module_loglevel(&(s)->log,i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 624| 0| (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (624:7): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:8): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:18): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:48): [True: 0, False: 0] | | | | | | | | | | | | | Branch (624:67): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 625| 0| (l)->level : \ | | | | | | | | | | | | 626| 0| (l)->module_levels[i]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (626:25): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (185:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 186| 0| >= ((level)&APLOG_LEVELMASK) ) ) | | | | | | | | ------------------ | | | | | | | | | | 60| 0|#define APLOG_LEVELMASK 15 /* mask off the level value */ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 367| 0| ap_log_error_(file, line, mi, level, status, sr__, __VA_ARGS__); \ | | | | | | ------------------ | | | | | | | Branch (367:40): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 368| 0| } while(0) | | | | | | ------------------ | | | | | | | Branch (368:13): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 631| 0| APLOGNO(03296) \ | | 632| 0| "expr parser fatal error (BUG?): " \ | | 633| 0| "%s, exiting", msg); \ | | 634| 0| if (unreachable) { \ | | ------------------ | | | Branch (634:13): [True: 0, False: 0] | | ------------------ | | 635| 0| /* Not reached, silence [-Wunused-function] */ \ | | 636| 0| yy_fatal_error(msg, yyscanner); \ | | 637| 0| } \ | | 638| 0| else { \ | | 639| 0| abort(); \ | | 640| 0| } \ | | 641| 0| } while (0) | | ------------------ | | | Branch (641:14): [Folded - Ignored] | | ------------------ ------------------ 2479| | 2480| 18.1k| BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]); ------------------ | | 131| 18.1k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ 2481| 18.1k|} util_expr_scan.c:yy_init_globals: 2716| 2.97k|{ 2717| 2.97k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2718| | /* Initialization is the same as for the non-reentrant scanner. 2719| | * This function is called from ap_expr_yylex_destroy(), so don't allocate here. 2720| | */ 2721| | 2722| 2.97k| yyg->yy_buffer_stack = NULL; 2723| 2.97k| yyg->yy_buffer_stack_top = 0; 2724| 2.97k| yyg->yy_buffer_stack_max = 0; 2725| 2.97k| yyg->yy_c_buf_p = NULL; 2726| 2.97k| yyg->yy_init = 0; 2727| 2.97k| yyg->yy_start = 0; 2728| | 2729| 2.97k| yyg->yy_start_stack_ptr = 0; 2730| 2.97k| yyg->yy_start_stack_depth = 0; 2731| 2.97k| yyg->yy_start_stack = NULL; 2732| | 2733| |/* Defined in main.c */ 2734| |#ifdef YY_STDINIT 2735| | yyin = stdin; 2736| | yyout = stdout; 2737| |#else 2738| 2.97k| yyin = NULL; ------------------ | | 118| 2.97k|#define yyin yyg->yyin_r ------------------ 2739| 2.97k| yyout = NULL; ------------------ | | 119| 2.97k|#define yyout yyg->yyout_r ------------------ 2740| 2.97k|#endif 2741| | 2742| | /* For future reference: Set errno on error, since we are called by 2743| | * ap_expr_yylex_init() 2744| | */ 2745| 2.97k| return 0; 2746| 2.97k|} ap_regfree: 156| 5.76k|{ 157| 5.76k|#ifdef HAVE_PCRE2 158| 5.76k| pcre2_code_free(preg->re_pcre); 159| |#else 160| | (pcre_free)(preg->re_pcre); 161| |#endif 162| 5.76k|} ap_regcomp: 213| 5.76k|{ 214| 5.76k|#ifdef HAVE_PCRE2 215| 5.76k| uint32_t capcount; 216| 5.76k| PCRE2_SIZE erroffset; 217| |#else 218| | const char *errorptr; 219| | int erroffset; 220| |#endif 221| 5.76k| int errcode = 0; 222| 5.76k| int options = PCREn(DUPNAMES); ------------------ | | 62| 5.76k|#define PCREn(x) PCRE2_ ## x ------------------ 223| | 224| 5.76k| if ((cflags & AP_REG_NO_DEFAULT) == 0) ------------------ | | 90| 5.76k|#define AP_REG_NO_DEFAULT 0x400 /**< Don't implicitely add AP_REG_DEFAULT options */ ------------------ | Branch (224:9): [True: 5.76k, False: 0] ------------------ 225| 5.76k| cflags |= default_cflags; 226| | 227| 5.76k| if ((cflags & AP_REG_ICASE) != 0) ------------------ | | 73| 5.76k|#define AP_REG_ICASE 0x01 /**< use a case-insensitive match */ ------------------ | Branch (227:9): [True: 6, False: 5.75k] ------------------ 228| 6| options |= PCREn(CASELESS); ------------------ | | 62| 6|#define PCREn(x) PCRE2_ ## x ------------------ 229| 5.76k| if ((cflags & AP_REG_NEWLINE) != 0) ------------------ | | 74| 5.76k|#define AP_REG_NEWLINE 0x02 /**< don't match newlines against '.' etc */ ------------------ | Branch (229:9): [True: 164, False: 5.60k] ------------------ 230| 164| options |= PCREn(MULTILINE); ------------------ | | 62| 164|#define PCREn(x) PCRE2_ ## x ------------------ 231| 5.76k| if ((cflags & AP_REG_DOTALL) != 0) ------------------ | | 83| 5.76k|#define AP_REG_DOTALL 0x40 /**< perl's /s flag */ ------------------ | Branch (231:9): [True: 5.76k, False: 0] ------------------ 232| 5.76k| options |= PCREn(DOTALL); ------------------ | | 62| 5.76k|#define PCREn(x) PCRE2_ ## x ------------------ 233| 5.76k| if ((cflags & AP_REG_DOLLAR_ENDONLY) != 0) ------------------ | | 88| 5.76k|#define AP_REG_DOLLAR_ENDONLY 0x200 /**< '$' matches at end of subject string only */ ------------------ | Branch (233:9): [True: 5.76k, False: 0] ------------------ 234| 5.76k| options |= PCREn(DOLLAR_ENDONLY); ------------------ | | 62| 5.76k|#define PCREn(x) PCRE2_ ## x ------------------ 235| | 236| 5.76k|#ifdef HAVE_PCRE2 237| 5.76k| preg->re_pcre = pcre2_compile((const unsigned char *)pattern, 238| 5.76k| PCRE2_ZERO_TERMINATED, options, &errcode, 239| 5.76k| &erroffset, NULL); 240| |#else 241| | preg->re_pcre = pcre_compile2(pattern, options, &errcode, 242| | &errorptr, &erroffset, NULL); 243| |#endif 244| | 245| 5.76k| preg->re_erroffset = erroffset; 246| 5.76k| if (preg->re_pcre == NULL) { ------------------ | Branch (246:9): [True: 0, False: 5.76k] ------------------ 247| | /* Internal ERR21 is "failed to get memory" according to pcreapi(3) */ 248| 0| if (errcode == 21) ------------------ | Branch (248:13): [True: 0, False: 0] ------------------ 249| 0| return AP_REG_ESPACE; 250| 0| return AP_REG_INVARG; 251| 0| } 252| | 253| 5.76k|#ifdef HAVE_PCRE2 254| 5.76k| pcre2_pattern_info((const pcre2_code *)preg->re_pcre, 255| 5.76k| PCRE2_INFO_CAPTURECOUNT, &capcount); 256| 5.76k| preg->re_nsub = capcount; 257| |#else 258| | pcre_fullinfo((const pcre *)preg->re_pcre, NULL, 259| | PCRE_INFO_CAPTURECOUNT, &(preg->re_nsub)); 260| |#endif 261| 5.76k| return 0; 262| 5.76k|} apr_atomic_init: 29| 1.51k|{ 30| |#if defined (USE_ATOMICS_GENERIC64) 31| | return apr__atomic_generic64_init(p); 32| |#else 33| 1.51k| return APR_SUCCESS; ------------------ | | 225| 1.51k|#define APR_SUCCESS 0 ------------------ 34| 1.51k|#endif 35| 1.51k|} ap_run_expr_lookup: 270| 2.03k| { \ 271| 2.03k| ns##_LINK_##name##_t *pHook; \ 272| 2.03k| int n; \ 273| 2.03k| ret rv = decline; \ 274| 2.03k| APR_HOOK_INT_DCL_UD; \ 275| 2.03k|\ 276| 2.03k| APR_HOOK_PROBE_ENTRY(ud, ns, name, args_use); \ 277| 2.03k|\ 278| 2.03k| if(_hooks.link_##name) \ ------------------ | Branch (278:8): [True: 0, False: 2.03k] ------------------ 279| 2.03k| { \ 280| 0| pHook=(ns##_LINK_##name##_t *)_hooks.link_##name->elts; \ 281| 0| for(n=0 ; n < _hooks.link_##name->nelts ; ++n) \ ------------------ | Branch (281:19): [True: 0, False: 0] ------------------ 282| 0| { \ 283| 0| APR_HOOK_PROBE_INVOKE(ud, ns, name, (char *)pHook[n].szName, args_use); \ 284| 0| rv=pHook[n].pFunc args_use; \ 285| 0| APR_HOOK_PROBE_COMPLETE(ud, ns, name, (char *)pHook[n].szName, rv, args_use); \ 286| 0|\ 287| 0| if(rv != decline) \ ------------------ | Branch (287:16): [True: 0, False: 0] ------------------ 288| 0| break; \ 289| 0| } \ 290| 0| } \ 291| 2.03k|\ 292| 2.03k| APR_HOOK_PROBE_RETURN(ud, ns, name, rv, args_use); \ 293| 2.03k|\ 294| 2.03k| return rv; \ 295| 2.03k| } apr_thread_mutex_create: 40| 1.51k|{ 41| 1.51k| apr_thread_mutex_t *new_mutex; 42| 1.51k| apr_status_t rv; 43| | 44| |#ifndef HAVE_PTHREAD_MUTEX_RECURSIVE 45| | if (flags & APR_THREAD_MUTEX_NESTED) { 46| | return APR_ENOTIMPL; 47| | } 48| |#endif 49| | 50| 1.51k| new_mutex = apr_pcalloc(pool, sizeof(apr_thread_mutex_t)); ------------------ | | 454| 1.51k| apr_pcalloc_debug(p, size, APR_POOL__FILE_LINE__) | | ------------------ | | | | 143| 1.51k|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 160| 1.51k|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 162| 1.51k|#define APR_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 51| 1.51k| new_mutex->pool = pool; 52| | 53| 1.51k|#ifdef HAVE_PTHREAD_MUTEX_RECURSIVE 54| 1.51k| if (flags & APR_THREAD_MUTEX_NESTED) { ------------------ | | 44| 1.51k|#define APR_THREAD_MUTEX_NESTED 0x1 /**< enable nested (recursive) locks */ ------------------ | Branch (54:9): [True: 1.51k, False: 0] ------------------ 55| 1.51k| pthread_mutexattr_t mattr; 56| | 57| 1.51k| rv = pthread_mutexattr_init(&mattr); 58| 1.51k| if (rv) return rv; ------------------ | Branch (58:13): [True: 0, False: 1.51k] ------------------ 59| | 60| 1.51k| rv = pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE); 61| 1.51k| if (rv) { ------------------ | Branch (61:13): [True: 0, False: 1.51k] ------------------ 62| 0| pthread_mutexattr_destroy(&mattr); 63| 0| return rv; 64| 0| } 65| | 66| 1.51k| rv = pthread_mutex_init(&new_mutex->mutex, &mattr); 67| | 68| 1.51k| pthread_mutexattr_destroy(&mattr); 69| 1.51k| } else 70| 0|#endif 71| 0| { 72| |#if defined(APR_THREAD_DEBUG) 73| | pthread_mutexattr_t mattr; 74| | 75| | rv = pthread_mutexattr_init(&mattr); 76| | if (rv) return rv; 77| | 78| | rv = pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_ERRORCHECK); 79| | if (rv) { 80| | pthread_mutexattr_destroy(&mattr); 81| | return rv; 82| | } 83| | 84| | rv = pthread_mutex_init(&new_mutex->mutex, &mattr); 85| | 86| | pthread_mutexattr_destroy(&mattr); 87| |#else 88| 0| rv = pthread_mutex_init(&new_mutex->mutex, NULL); 89| 0|#endif 90| 0| } 91| | 92| 1.51k| if (rv) { ------------------ | Branch (92:9): [True: 0, False: 1.51k] ------------------ 93| |#ifdef HAVE_ZOS_PTHREADS 94| | rv = errno; 95| |#endif 96| 0| return rv; 97| 0| } 98| | 99| |#ifndef HAVE_PTHREAD_MUTEX_TIMEDLOCK 100| | if (flags & APR_THREAD_MUTEX_TIMED) { 101| | rv = apr_thread_cond_create(&new_mutex->cond, pool); 102| | if (rv) { 103| |#ifdef HAVE_ZOS_PTHREADS 104| | rv = errno; 105| |#endif 106| | pthread_mutex_destroy(&new_mutex->mutex); 107| | return rv; 108| | } 109| | } 110| |#endif 111| | 112| 1.51k| apr_pool_cleanup_register(new_mutex->pool, 113| 1.51k| new_mutex, thread_mutex_cleanup, 114| 1.51k| apr_pool_cleanup_null); 115| | 116| 1.51k| *mutex = new_mutex; 117| 1.51k| return APR_SUCCESS; ------------------ | | 225| 1.51k|#define APR_SUCCESS 0 ------------------ 118| 1.51k|} apr_thread_mutex_lock: 121| 1.51k|{ 122| 1.51k| apr_status_t rv; 123| | 124| |#ifndef HAVE_PTHREAD_MUTEX_TIMEDLOCK 125| | if (mutex->cond) { 126| | apr_status_t rv2; 127| | 128| | rv = pthread_mutex_lock(&mutex->mutex); 129| | if (rv) { 130| |#ifdef HAVE_ZOS_PTHREADS 131| | rv = errno; 132| |#endif 133| | return rv; 134| | } 135| | 136| | if (mutex->locked) { 137| | mutex->num_waiters++; 138| | rv = apr_thread_cond_wait(mutex->cond, mutex); 139| | mutex->num_waiters--; 140| | } 141| | else { 142| | mutex->locked = 1; 143| | } 144| | 145| | rv2 = pthread_mutex_unlock(&mutex->mutex); 146| | if (rv2 && !rv) { 147| |#ifdef HAVE_ZOS_PTHREADS 148| | rv = errno; 149| |#else 150| | rv = rv2; 151| |#endif 152| | } 153| | 154| | return rv; 155| | } 156| |#endif 157| | 158| 1.51k| rv = pthread_mutex_lock(&mutex->mutex); 159| |#ifdef HAVE_ZOS_PTHREADS 160| | if (rv) { 161| | rv = errno; 162| | } 163| |#endif 164| | 165| 1.51k| return rv; 166| 1.51k|} apr_thread_mutex_unlock: 302| 1.51k|{ 303| 1.51k| apr_status_t status; 304| | 305| |#ifndef HAVE_PTHREAD_MUTEX_TIMEDLOCK 306| | if (mutex->cond) { 307| | status = pthread_mutex_lock(&mutex->mutex); 308| | if (status) { 309| |#ifdef HAVE_ZOS_PTHREADS 310| | status = errno; 311| |#endif 312| | return status; 313| | } 314| | 315| | if (!mutex->locked) { 316| | status = APR_EINVAL; 317| | } 318| | else if (mutex->num_waiters) { 319| | status = apr_thread_cond_signal(mutex->cond); 320| | } 321| | if (status) { 322| | pthread_mutex_unlock(&mutex->mutex); 323| | return status; 324| | } 325| | 326| | mutex->locked = 0; 327| | } 328| |#endif 329| | 330| 1.51k| status = pthread_mutex_unlock(&mutex->mutex); 331| |#ifdef HAVE_ZOS_PTHREADS 332| | if (status) { 333| | status = errno; 334| | } 335| |#endif 336| | 337| 1.51k| return status; 338| 1.51k|} thread_mutex.c:thread_mutex_cleanup: 24| 1.51k|{ 25| 1.51k| apr_thread_mutex_t *mutex = data; 26| 1.51k| apr_status_t rv; 27| | 28| 1.51k| rv = pthread_mutex_destroy(&mutex->mutex); 29| |#ifdef HAVE_ZOS_PTHREADS 30| | if (rv) { 31| | rv = errno; 32| | } 33| |#endif 34| 1.51k| return rv; 35| 1.51k|} apr_pool_initialize: 1674| 1.51k|{ 1675| 1.51k| apr_status_t rv; 1676| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALL) 1677| | char *logpath; 1678| | apr_file_t *debug_log = NULL; 1679| |#endif 1680| | 1681| 1.51k| if (apr_pools_initialized++) ------------------ | Branch (1681:9): [True: 0, False: 1.51k] ------------------ 1682| 0| return APR_SUCCESS; ------------------ | | 225| 0|#define APR_SUCCESS 0 ------------------ 1683| | 1684| 1.51k|#if defined(_SC_PAGESIZE) 1685| 1.51k| boundary_size = sysconf(_SC_PAGESIZE); 1686| |#elif defined(WIN32) 1687| | { 1688| | SYSTEM_INFO si; 1689| | GetSystemInfo(&si); 1690| | boundary_size = si.dwPageSize; 1691| | } 1692| |#endif 1693| 1.51k| boundary_index = 12; 1694| 1.51k| while ( (1 << boundary_index) < boundary_size) ------------------ | Branch (1694:13): [True: 0, False: 1.51k] ------------------ 1695| 0| boundary_index++; 1696| 1.51k| boundary_size = (1 << boundary_index); 1697| | 1698| | /* Since the debug code works a bit differently then the 1699| | * regular pools code, we ask for a lock here. The regular 1700| | * pools code has got this lock embedded in the global 1701| | * allocator, a concept unknown to debug mode. 1702| | */ 1703| 1.51k| if ((rv = apr_pool_create_ex(&global_pool, NULL, NULL, ------------------ | | 247| 1.51k| apr_pool_create_ex_debug(newpool, parent, abort_fn, allocator, \ | | 248| 1.51k| APR_POOL__FILE_LINE__) | | ------------------ | | | | 143| 1.51k|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 160| 1.51k|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 162| 1.51k|#define APR_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1703:9): [True: 0, False: 1.51k] ------------------ 1704| 1.51k| NULL)) != APR_SUCCESS) { ------------------ | | 225| 1.51k|#define APR_SUCCESS 0 ------------------ 1705| 0| return rv; 1706| 0| } 1707| | 1708| 1.51k| apr_pool_tag(global_pool, "APR global pool"); 1709| | 1710| 1.51k| apr_pools_initialized = 1; 1711| | 1712| | /* This has to happen here because mutexes might be backed by 1713| | * atomics. It used to be snug and safe in apr_initialize(). 1714| | */ 1715| 1.51k| if ((rv = apr_atomic_init(global_pool)) != APR_SUCCESS) { ------------------ | | 225| 1.51k|#define APR_SUCCESS 0 ------------------ | Branch (1715:9): [True: 0, False: 1.51k] ------------------ 1716| 0| return rv; 1717| 0| } 1718| | 1719| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALL) 1720| | rv = apr_env_get(&logpath, "APR_POOL_DEBUG_LOG", global_pool); 1721| | 1722| | /* Don't pass file_stderr directly to apr_file_open() here, since 1723| | * apr_file_open() can call back to apr_pool_log_event() and that 1724| | * may attempt to use then then non-NULL but partially set up file 1725| | * object. */ 1726| | if (rv == APR_SUCCESS) { 1727| | apr_file_open(&debug_log, logpath, 1728| | APR_FOPEN_APPEND|APR_FOPEN_WRITE|APR_FOPEN_CREATE, 1729| | APR_FPROT_OS_DEFAULT, global_pool); 1730| | } 1731| | else { 1732| | apr_file_open_stderr(&debug_log, global_pool); 1733| | } 1734| | 1735| | /* debug_log is now a file handle. */ 1736| | file_stderr = debug_log; 1737| | 1738| | if (file_stderr) { 1739| | apr_file_printf(file_stderr, 1740| | "POOL DEBUG: [PID" 1741| |#if APR_HAS_THREADS 1742| | "/TID" 1743| |#endif /* APR_HAS_THREADS */ 1744| | "] ACTION (SIZE /POOL SIZE /TOTAL SIZE) " 1745| | "POOL \"TAG\" <__FILE__:__LINE__> PARENT (ALLOCS/TOTAL ALLOCS/CLEARS)\n"); 1746| | 1747| | apr_pool_log_event(global_pool, "GLOBAL", __FILE__ ":apr_pool_initialize", 0); 1748| | 1749| | /* Add a cleanup handler that sets the debug log file handle 1750| | * to NULL, otherwise we'll try to log the global pool 1751| | * destruction event with predictably disastrous results. */ 1752| | apr_pool_cleanup_register(global_pool, NULL, 1753| | apr_pool_cleanup_file_stderr, 1754| | apr_pool_cleanup_null); 1755| | } 1756| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALL) */ 1757| | 1758| 1.51k| return APR_SUCCESS; ------------------ | | 225| 1.51k|#define APR_SUCCESS 0 ------------------ 1759| 1.51k|} apr_pool_terminate: 1762| 1.51k|{ 1763| 1.51k| if (!apr_pools_initialized) ------------------ | Branch (1763:9): [True: 0, False: 1.51k] ------------------ 1764| 0| return; 1765| | 1766| 1.51k| if (--apr_pools_initialized) ------------------ | Branch (1766:9): [True: 0, False: 1.51k] ------------------ 1767| 0| return; 1768| | 1769| 1.51k| apr_pool_destroy(global_pool); /* This will also destroy the mutex */ ------------------ | | 388| 1.51k| apr_pool_destroy_debug(p, APR_POOL__FILE_LINE__) | | ------------------ | | | | 143| 1.51k|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 160| 1.51k|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 162| 1.51k|#define APR_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1770| 1.51k| global_pool = NULL; 1771| | 1772| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALL) 1773| | file_stderr = NULL; 1774| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALL) */ 1775| 1.51k|} apr_palloc_debug: 1823| 145k|{ 1824| 145k| void *mem; 1825| | 1826| 145k| apr_pool_check_integrity(pool); 1827| | 1828| 145k| mem = pool_alloc(pool, size); 1829| | 1830| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALLOC) 1831| | apr_pool_log_event(pool, "PALLOC", file_line, 1); 1832| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALLOC) */ 1833| | 1834| 145k| return mem; 1835| 145k|} apr_pcalloc_debug: 1839| 7.28k|{ 1840| 7.28k| void *mem; 1841| | 1842| 7.28k| apr_pool_check_integrity(pool); 1843| | 1844| 7.28k| mem = pool_alloc(pool, size); 1845| 7.28k| memset(mem, 0, size); 1846| | 1847| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALLOC) 1848| | apr_pool_log_event(pool, "PCALLOC", file_line, 1); 1849| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALLOC) */ 1850| | 1851| 7.28k| return mem; 1852| 7.28k|} apr_pool_destroy_debug: 1985| 1.51k|{ 1986| 1.51k|#if APR_HAS_THREADS 1987| 1.51k| apr_thread_mutex_t *mutex; 1988| 1.51k|#endif 1989| | 1990| 1.51k| apr_pool_check_lifetime(pool); 1991| | 1992| 1.51k| if (pool->joined) { ------------------ | Branch (1992:9): [True: 0, False: 1.51k] ------------------ 1993| | /* Joined pools must not be explicitly destroyed; the caller 1994| | * has broken the guarantee. */ 1995| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALL) 1996| | apr_pool_log_event(pool, "LIFE", 1997| | __FILE__ ":apr_pool_destroy abort on joined", 0); 1998| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALL) */ 1999| | 2000| 0| abort(); 2001| 0| } 2002| | 2003| 1.51k|#if APR_HAS_THREADS 2004| | /* Lock the parent mutex before destroying so that it's not accessed 2005| | * concurrently by apr_pool_walk_tree. 2006| | */ 2007| 1.51k| mutex = parent_lock(pool); 2008| 1.51k|#endif 2009| | 2010| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE) 2011| | apr_pool_log_event(pool, "DESTROY", file_line, 1); 2012| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE) */ 2013| | 2014| 1.51k| pool_destroy_debug(pool, file_line); 2015| | 2016| 1.51k|#if APR_HAS_THREADS 2017| | /* Unlock the mutex we obtained above */ 2018| 1.51k| parent_unlock(mutex); 2019| 1.51k|#endif /* APR_HAS_THREADS */ 2020| 1.51k|} apr_pool_create_ex_debug: 2027| 3.03k|{ 2028| 3.03k| apr_pool_t *pool; 2029| | 2030| 3.03k| *newpool = NULL; 2031| | 2032| 3.03k| if (!parent) { ------------------ | Branch (2032:9): [True: 3.03k, False: 0] ------------------ 2033| 3.03k| parent = global_pool; 2034| 3.03k| } 2035| 0| else { 2036| 0| apr_pool_check_lifetime(parent); 2037| | 2038| 0| if (!allocator) ------------------ | Branch (2038:12): [True: 0, False: 0] ------------------ 2039| 0| allocator = parent->allocator; 2040| 0| } 2041| | 2042| 3.03k| if (!abort_fn && parent) ------------------ | Branch (2042:9): [True: 3.03k, False: 0] | Branch (2042:22): [True: 1.51k, False: 1.51k] ------------------ 2043| 1.51k| abort_fn = parent->abort_fn; 2044| | 2045| 3.03k| if ((pool = malloc(SIZEOF_POOL_T)) == NULL) { ------------------ | | 618| 3.03k|#define SIZEOF_POOL_T APR_ALIGN_DEFAULT(sizeof(apr_pool_t)) | | ------------------ | | | | 150| 3.03k|#define APR_ALIGN_DEFAULT(size) APR_ALIGN(size, 8) | | | | ------------------ | | | | | | 147| 3.03k| (((size) + ((boundary) - 1)) & ~((boundary) - 1)) | | | | ------------------ | | ------------------ ------------------ | Branch (2045:9): [True: 0, False: 3.03k] ------------------ 2046| 0| if (abort_fn) ------------------ | Branch (2046:13): [True: 0, False: 0] ------------------ 2047| 0| abort_fn(APR_ENOMEM); ------------------ | | 687| 0|#define APR_ENOMEM ENOMEM ------------------ 2048| | 2049| 0| return APR_ENOMEM; ------------------ | | 687| 0|#define APR_ENOMEM ENOMEM ------------------ 2050| 0| } 2051| | 2052| 3.03k| memset(pool, 0, SIZEOF_POOL_T); ------------------ | | 618| 3.03k|#define SIZEOF_POOL_T APR_ALIGN_DEFAULT(sizeof(apr_pool_t)) | | ------------------ | | | | 150| 3.03k|#define APR_ALIGN_DEFAULT(size) APR_ALIGN(size, 8) | | | | ------------------ | | | | | | 147| 3.03k| (((size) + ((boundary) - 1)) & ~((boundary) - 1)) | | | | ------------------ | | ------------------ ------------------ 2053| | 2054| 3.03k| pool->allocator = allocator; 2055| 3.03k| pool->abort_fn = abort_fn; 2056| 3.03k| pool->tag = file_line; 2057| 3.03k| pool->file_line = file_line; 2058| | 2059| 3.03k|#if APR_HAS_THREADS 2060| 3.03k| pool->owner = apr_os_thread_current(); 2061| 3.03k|#endif /* APR_HAS_THREADS */ 2062| |#ifdef NETWARE 2063| | pool->owner_proc = (apr_os_proc_t)getnlmhandle(); 2064| |#endif /* defined(NETWARE) */ 2065| | 2066| 3.03k|#if APR_HAS_THREADS 2067| 3.03k| if (parent == NULL || parent->allocator != allocator) { ------------------ | Branch (2067:9): [True: 1.51k, False: 1.51k] | Branch (2067:27): [True: 0, False: 1.51k] ------------------ 2068| 1.51k| apr_status_t rv; 2069| | 2070| | /* No matter what the creation flags say, always create 2071| | * a lock. Without it integrity_check and apr_pool_num_bytes 2072| | * blow up (because they traverse pools child lists that 2073| | * possibly belong to another thread, in combination with 2074| | * the pool having no lock). However, this might actually 2075| | * hide problems like creating a child pool of a pool 2076| | * belonging to another thread. 2077| | */ 2078| 1.51k| if ((rv = apr_thread_mutex_create(&pool->mutex, ------------------ | Branch (2078:13): [True: 0, False: 1.51k] ------------------ 2079| 1.51k| APR_THREAD_MUTEX_NESTED, pool)) != APR_SUCCESS) { ------------------ | | 44| 1.51k|#define APR_THREAD_MUTEX_NESTED 0x1 /**< enable nested (recursive) locks */ ------------------ APR_THREAD_MUTEX_NESTED, pool)) != APR_SUCCESS) { ------------------ | | 225| 1.51k|#define APR_SUCCESS 0 ------------------ 2080| 0| free(pool); 2081| 0| return rv; 2082| 0| } 2083| 1.51k| } 2084| 1.51k| else { 2085| 1.51k| pool->mutex = parent->mutex; 2086| 1.51k| } 2087| 3.03k|#endif /* APR_HAS_THREADS */ 2088| | 2089| 3.03k| if ((pool->parent = parent) != NULL) { ------------------ | Branch (2089:9): [True: 1.51k, False: 1.51k] ------------------ 2090| 1.51k| pool_lock(parent); 2091| | 2092| 1.51k| if ((pool->sibling = parent->child) != NULL) ------------------ | Branch (2092:13): [True: 0, False: 1.51k] ------------------ 2093| 0| pool->sibling->ref = &pool->sibling; 2094| | 2095| 1.51k| parent->child = pool; 2096| 1.51k| pool->ref = &parent->child; 2097| | 2098| 1.51k| pool_unlock(parent); 2099| 1.51k| } 2100| 1.51k| else { 2101| 1.51k| pool->sibling = NULL; 2102| 1.51k| pool->ref = NULL; 2103| 1.51k| } 2104| | 2105| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE) 2106| | apr_pool_log_event(pool, "CREATE", file_line, 1); 2107| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE) */ 2108| | 2109| 3.03k| *newpool = pool; 2110| | 2111| 3.03k| return APR_SUCCESS; ------------------ | | 225| 3.03k|#define APR_SUCCESS 0 ------------------ 2112| 3.03k|} apr_pvsprintf: 2212| 75|{ 2213| 75| struct psprintf_data ps; 2214| 75| debug_node_t *node; 2215| | 2216| 75| apr_pool_check_integrity(pool); 2217| | 2218| 75| ps.size = 64; 2219| 75| ps.mem = malloc(ps.size); 2220| 75| ps.vbuff.curpos = ps.mem; 2221| | 2222| | /* Save a byte for the NUL terminator */ 2223| 75| ps.vbuff.endpos = ps.mem + ps.size - 1; 2224| | 2225| 75| if (apr_vformatter(psprintf_flush, &ps.vbuff, fmt, ap) == -1) { ------------------ | Branch (2225:9): [True: 0, False: 75] ------------------ 2226| 0| if (pool->abort_fn) ------------------ | Branch (2226:13): [True: 0, False: 0] ------------------ 2227| 0| pool->abort_fn(APR_ENOMEM); ------------------ | | 687| 0|#define APR_ENOMEM ENOMEM ------------------ 2228| | 2229| 0| return NULL; 2230| 0| } 2231| | 2232| 75| *ps.vbuff.curpos++ = '\0'; 2233| | 2234| | /* 2235| | * Link the node in 2236| | */ 2237| 75| node = pool->nodes; 2238| 75| if (node == NULL || node->index == 64) { ------------------ | Branch (2238:9): [True: 0, False: 75] | Branch (2238:25): [True: 5, False: 70] ------------------ 2239| 5| if ((node = malloc(SIZEOF_DEBUG_NODE_T)) == NULL) { ------------------ | | 562| 5|#define SIZEOF_DEBUG_NODE_T APR_ALIGN_DEFAULT(sizeof(debug_node_t)) | | ------------------ | | | | 150| 5|#define APR_ALIGN_DEFAULT(size) APR_ALIGN(size, 8) | | | | ------------------ | | | | | | 147| 5| (((size) + ((boundary) - 1)) & ~((boundary) - 1)) | | | | ------------------ | | ------------------ ------------------ | Branch (2239:13): [True: 0, False: 5] ------------------ 2240| 0| if (pool->abort_fn) ------------------ | Branch (2240:17): [True: 0, False: 0] ------------------ 2241| 0| pool->abort_fn(APR_ENOMEM); ------------------ | | 687| 0|#define APR_ENOMEM ENOMEM ------------------ 2242| | 2243| 0| return NULL; 2244| 0| } 2245| | 2246| 5| node->next = pool->nodes; 2247| 5| pool->nodes = node; 2248| 5| node->index = 0; 2249| 5| } 2250| | 2251| 75| node->beginp[node->index] = ps.mem; 2252| 75| node->endp[node->index] = ps.mem + ps.size; 2253| 75| node->index++; 2254| | 2255| 75| return ps.mem; 2256| 75|} apr_psprintf: 2371| 75|{ 2372| 75| va_list ap; 2373| 75| char *res; 2374| | 2375| 75| va_start(ap, fmt); 2376| 75| res = apr_pvsprintf(p, fmt, ap); 2377| 75| va_end(ap); 2378| 75| return res; 2379| 75|} apr_pool_tag: 2440| 1.51k|{ 2441| 1.51k| pool->tag = tag; 2442| 1.51k|} apr_pool_cleanup_register: 2530| 7.28k|{ 2531| 7.28k| cleanup_t *c = NULL; 2532| | 2533| 7.28k|#if APR_POOL_DEBUG 2534| 7.28k| apr_pool_check_integrity(p); 2535| 7.28k|#endif /* APR_POOL_DEBUG */ 2536| | 2537| 7.28k| if (p != NULL) { ------------------ | Branch (2537:9): [True: 7.28k, False: 0] ------------------ 2538| 7.28k| if (p->free_cleanups) { ------------------ | Branch (2538:13): [True: 0, False: 7.28k] ------------------ 2539| | /* reuse a cleanup structure */ 2540| 0| c = p->free_cleanups; 2541| 0| p->free_cleanups = c->next; 2542| 7.28k| } else { 2543| 7.28k| c = apr_palloc(p, sizeof(cleanup_t)); ------------------ | | 425| 7.28k| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | ------------------ | | | | 143| 7.28k|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 160| 7.28k|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 162| 7.28k|#define APR_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2544| 7.28k| } 2545| 7.28k| c->data = data; 2546| 7.28k| c->plain_cleanup_fn = plain_cleanup_fn; 2547| 7.28k| c->child_cleanup_fn = child_cleanup_fn; 2548| 7.28k| c->next = p->cleanups; 2549| 7.28k| p->cleanups = c; 2550| 7.28k| } 2551| | 2552| 7.28k|#if APR_POOL_DEBUG 2553| 7.28k| if (!c || !c->plain_cleanup_fn || !c->child_cleanup_fn) { ------------------ | Branch (2553:9): [True: 0, False: 7.28k] | Branch (2553:15): [True: 0, False: 7.28k] | Branch (2553:39): [True: 0, False: 7.28k] ------------------ 2554| 0| abort(); 2555| 0| } 2556| 7.28k|#endif /* APR_POOL_DEBUG */ 2557| 7.28k|} apr_pool_create_ex: 2979| 1.51k|{ 2980| 1.51k| return apr_pool_create_ex_debug(newpool, parent, 2981| 1.51k| abort_fn, allocator, 2982| 1.51k| "undefined"); 2983| 1.51k|} apr_pools.c:apr_pool_check_integrity: 1657| 159k|{ 1658| 159k| apr_pool_check_lifetime(pool); 1659| 159k| apr_pool_check_owner(pool); 1660| 159k|} apr_pools.c:apr_pool_check_owner: 1642| 162k|{ 1643| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_OWNER) 1644| |#if APR_HAS_THREADS 1645| | if (!apr_os_thread_equal(pool->owner, apr_os_thread_current())) { 1646| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALL) 1647| | apr_pool_log_event(pool, "THREAD", 1648| | __FILE__ ":apr_pool_integrity check [owner]", 0); 1649| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALL) */ 1650| | abort(); 1651| | } 1652| |#endif /* APR_HAS_THREADS */ 1653| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_OWNER) */ 1654| 162k|} apr_pools.c:pool_alloc: 1783| 152k|{ 1784| 152k| debug_node_t *node; 1785| 152k| void *mem; 1786| | 1787| 152k| if ((mem = malloc(size)) == NULL) { ------------------ | Branch (1787:9): [True: 0, False: 152k] ------------------ 1788| 0| if (pool->abort_fn) ------------------ | Branch (1788:13): [True: 0, False: 0] ------------------ 1789| 0| pool->abort_fn(APR_ENOMEM); ------------------ | | 687| 0|#define APR_ENOMEM ENOMEM ------------------ 1790| | 1791| 0| return NULL; 1792| 0| } 1793| | 1794| 152k| node = pool->nodes; 1795| 152k| if (node == NULL || node->index == 64) { ------------------ | Branch (1795:9): [True: 3.00k, False: 149k] | Branch (1795:25): [True: 2.17k, False: 147k] ------------------ 1796| 5.17k| if ((node = malloc(SIZEOF_DEBUG_NODE_T)) == NULL) { ------------------ | | 562| 5.17k|#define SIZEOF_DEBUG_NODE_T APR_ALIGN_DEFAULT(sizeof(debug_node_t)) | | ------------------ | | | | 150| 5.17k|#define APR_ALIGN_DEFAULT(size) APR_ALIGN(size, 8) | | | | ------------------ | | | | | | 147| 5.17k| (((size) + ((boundary) - 1)) & ~((boundary) - 1)) | | | | ------------------ | | ------------------ ------------------ | Branch (1796:13): [True: 0, False: 5.17k] ------------------ 1797| 0| free(mem); 1798| 0| if (pool->abort_fn) ------------------ | Branch (1798:17): [True: 0, False: 0] ------------------ 1799| 0| pool->abort_fn(APR_ENOMEM); ------------------ | | 687| 0|#define APR_ENOMEM ENOMEM ------------------ 1800| | 1801| 0| return NULL; 1802| 0| } 1803| | 1804| 5.17k| memset(node, 0, SIZEOF_DEBUG_NODE_T); ------------------ | | 562| 5.17k|#define SIZEOF_DEBUG_NODE_T APR_ALIGN_DEFAULT(sizeof(debug_node_t)) | | ------------------ | | | | 150| 5.17k|#define APR_ALIGN_DEFAULT(size) APR_ALIGN(size, 8) | | | | ------------------ | | | | | | 147| 5.17k| (((size) + ((boundary) - 1)) & ~((boundary) - 1)) | | | | ------------------ | | ------------------ ------------------ 1805| | 1806| 5.17k| node->next = pool->nodes; 1807| 5.17k| pool->nodes = node; 1808| 5.17k| node->index = 0; 1809| 5.17k| } 1810| | 1811| 152k| node->beginp[node->index] = mem; 1812| 152k| node->endp[node->index] = (char *)mem + size; 1813| 152k| node->index++; 1814| | 1815| 152k| pool->stat_alloc++; 1816| 152k| pool->stat_total_alloc++; 1817| | 1818| 152k| return mem; 1819| 152k|} apr_pools.c:apr_pool_check_lifetime: 1616| 161k|{ 1617| | /* Rule of thumb: use of the global pool is always 1618| | * ok, since the only user is apr_pools.c. Unless 1619| | * people have searched for the top level parent and 1620| | * started to use that... 1621| | */ 1622| 161k| if (pool == global_pool || global_pool == NULL) ------------------ | Branch (1622:9): [True: 1.51k, False: 159k] | Branch (1622:32): [True: 4.55k, False: 155k] ------------------ 1623| 6.07k| return; 1624| | 1625| | /* Lifetime 1626| | * This basically checks to see if the pool being used is still 1627| | * a relative to the global pool. If not it was previously 1628| | * destroyed, in which case we abort(). 1629| | */ 1630| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_LIFETIME) 1631| | if (!apr_pool_is_child_of(pool, global_pool)) { 1632| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALL) 1633| | apr_pool_log_event(pool, "LIFE", 1634| | __FILE__ ":apr_pool_integrity check [lifetime]", 0); 1635| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE_ALL) */ 1636| | abort(); 1637| | } 1638| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_LIFETIME) */ 1639| 161k|} apr_pools.c:parent_lock: 1491| 1.51k|{ 1492| 1.51k| if (pool->parent) { ------------------ | Branch (1492:9): [True: 0, False: 1.51k] ------------------ 1493| 0| apr_thread_mutex_lock(pool->parent->mutex); 1494| 0| return pool->parent->mutex; 1495| 0| } 1496| 1.51k| return NULL; 1497| 1.51k|} apr_pools.c:pool_clear_debug: 1862| 3.03k|{ 1863| 3.03k| debug_node_t *node; 1864| 3.03k| apr_size_t index; 1865| | 1866| | /* Run pre destroy cleanups */ 1867| 3.03k| run_cleanups(&pool->pre_cleanups); 1868| 3.03k| pool->pre_cleanups = NULL; 1869| | 1870| | /* 1871| | * Now that we have given the pre cleanups the chance to kill of any 1872| | * threads using the pool, the owner must be correct. 1873| | */ 1874| 3.03k| apr_pool_check_owner(pool); 1875| | 1876| | /* Destroy the subpools. The subpools will detach themselves from 1877| | * this pool thus this loop is safe and easy. 1878| | */ 1879| 4.55k| while (pool->child) ------------------ | Branch (1879:12): [True: 1.51k, False: 3.03k] ------------------ 1880| 1.51k| pool_destroy_debug(pool->child, file_line); 1881| | 1882| | /* Run cleanups */ 1883| 3.03k| run_cleanups(&pool->cleanups); 1884| 3.03k| pool->free_cleanups = NULL; 1885| 3.03k| pool->cleanups = NULL; 1886| | 1887| | /* If new child pools showed up, this is a reason to raise a flag */ 1888| 3.03k| if (pool->child) ------------------ | Branch (1888:9): [True: 0, False: 3.03k] ------------------ 1889| 0| abort(); 1890| | 1891| | /* Free subprocesses */ 1892| 3.03k| free_proc_chain(pool->subprocesses); 1893| 3.03k| pool->subprocesses = NULL; 1894| | 1895| | /* Clear the user data. */ 1896| 3.03k| pool->user_data = NULL; 1897| | 1898| | /* Free the blocks, scribbling over them first to help highlight 1899| | * use-after-free issues. */ 1900| 8.21k| while ((node = pool->nodes) != NULL) { ------------------ | Branch (1900:12): [True: 5.18k, False: 3.03k] ------------------ 1901| 5.18k| pool->nodes = node->next; 1902| | 1903| 157k| for (index = 0; index < node->index; index++) { ------------------ | Branch (1903:25): [True: 152k, False: 5.18k] ------------------ 1904| 152k| memset(node->beginp[index], POOL_POISON_BYTE, ------------------ | | 1859| 152k|#define POOL_POISON_BYTE 'A' ------------------ 1905| 152k| (char *)node->endp[index] - (char *)node->beginp[index]); 1906| 152k| free(node->beginp[index]); 1907| 152k| } 1908| | 1909| 5.18k| memset(node, POOL_POISON_BYTE, SIZEOF_DEBUG_NODE_T); ------------------ | | 1859| 5.18k|#define POOL_POISON_BYTE 'A' ------------------ memset(node, POOL_POISON_BYTE, SIZEOF_DEBUG_NODE_T); ------------------ | | 562| 5.18k|#define SIZEOF_DEBUG_NODE_T APR_ALIGN_DEFAULT(sizeof(debug_node_t)) | | ------------------ | | | | 150| 5.18k|#define APR_ALIGN_DEFAULT(size) APR_ALIGN(size, 8) | | | | ------------------ | | | | | | 147| 5.18k| (((size) + ((boundary) - 1)) & ~((boundary) - 1)) | | | | ------------------ | | ------------------ ------------------ 1910| 5.18k| free(node); 1911| 5.18k| } 1912| | 1913| 3.03k| pool->stat_alloc = 0; 1914| 3.03k| pool->stat_clear++; 1915| | 1916| |#if (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE) 1917| | apr_pool_log_event(pool, "CLEARED", file_line, 1); 1918| |#endif /* (APR_POOL_DEBUG & APR_POOL_DEBUG_VERBOSE) */ 1919| 3.03k|} apr_pools.c:run_cleanups: 2684| 6.07k|{ 2685| 6.07k| cleanup_t *c = *cref; 2686| | 2687| 13.3k| while (c) { ------------------ | Branch (2687:12): [True: 7.28k, False: 6.07k] ------------------ 2688| 7.28k| *cref = c->next; 2689| 7.28k| (*c->plain_cleanup_fn)((void *)c->data); 2690| 7.28k| c = *cref; 2691| 7.28k| } 2692| 6.07k|} apr_pools.c:free_proc_chain: 2764| 3.03k|{ 2765| | /* Dispose of the subprocesses we've spawned off in the course of 2766| | * whatever it was we're cleaning up now. This may involve killing 2767| | * some of them off... 2768| | */ 2769| 3.03k| struct process_chain *pc; 2770| 3.03k| int need_timeout = 0; 2771| 3.03k| apr_time_t timeout_interval; 2772| | 2773| 3.03k| if (!procs) ------------------ | Branch (2773:9): [True: 3.03k, False: 0] ------------------ 2774| 3.03k| return; /* No work. Whew! */ 2775| | 2776| | /* First, check to see if we need to do the SIGTERM, sleep, SIGKILL 2777| | * dance with any of the processes we're cleaning up. If we've got 2778| | * any kill-on-sight subprocesses, ditch them now as well, so they 2779| | * don't waste any more cycles doing whatever it is that they shouldn't 2780| | * be doing anymore. 2781| | */ 2782| | 2783| 0|#ifndef NEED_WAITPID 2784| | /* Pick up all defunct processes */ 2785| 0| for (pc = procs; pc; pc = pc->next) { ------------------ | Branch (2785:22): [True: 0, False: 0] ------------------ 2786| 0| if (apr_proc_wait(pc->proc, NULL, NULL, APR_NOWAIT) != APR_CHILD_NOTDONE) ------------------ | | 454| 0|#define APR_CHILD_NOTDONE (APR_OS_START_STATUS + 6) | | ------------------ | | | | 136| 0|#define APR_OS_START_STATUS (APR_OS_START_ERROR + APR_OS_ERRSPACE_SIZE) | | | | ------------------ | | | | | | 117| 0|#define APR_OS_START_ERROR 20000 | | | | ------------------ | | | | #define APR_OS_START_STATUS (APR_OS_START_ERROR + APR_OS_ERRSPACE_SIZE) | | | | ------------------ | | | | | | 123| 0|#define APR_OS_ERRSPACE_SIZE 50000 | | | | ------------------ | | ------------------ ------------------ | Branch (2786:13): [True: 0, False: 0] ------------------ 2787| 0| pc->kill_how = APR_KILL_NEVER; 2788| 0| } 2789| 0|#endif /* !defined(NEED_WAITPID) */ 2790| | 2791| 0| for (pc = procs; pc; pc = pc->next) { ------------------ | Branch (2791:22): [True: 0, False: 0] ------------------ 2792| 0|#ifndef WIN32 2793| 0| if ((pc->kill_how == APR_KILL_AFTER_TIMEOUT) ------------------ | Branch (2793:13): [True: 0, False: 0] ------------------ 2794| 0| || (pc->kill_how == APR_KILL_ONLY_ONCE)) { ------------------ | Branch (2794:16): [True: 0, False: 0] ------------------ 2795| | /* 2796| | * Subprocess may be dead already. Only need the timeout if not. 2797| | * Note: apr_proc_kill on Windows is TerminateProcess(), which is 2798| | * similar to a SIGKILL, so always give the process a timeout 2799| | * under Windows before killing it. 2800| | */ 2801| 0| if (apr_proc_kill(pc->proc, SIGTERM) == APR_SUCCESS) ------------------ | | 225| 0|#define APR_SUCCESS 0 ------------------ | Branch (2801:17): [True: 0, False: 0] ------------------ 2802| 0| need_timeout = 1; 2803| 0| } 2804| 0| else if (pc->kill_how == APR_KILL_ALWAYS) { ------------------ | Branch (2804:18): [True: 0, False: 0] ------------------ 2805| |#else /* WIN32 knows only one fast, clean method of killing processes today */ 2806| | if (pc->kill_how != APR_KILL_NEVER) { 2807| | need_timeout = 1; 2808| | pc->kill_how = APR_KILL_ALWAYS; 2809| |#endif 2810| 0| apr_proc_kill(pc->proc, SIGKILL); 2811| 0| } 2812| 0| } 2813| | 2814| | /* Sleep only if we have to. The sleep algorithm grows 2815| | * by a factor of two on each iteration. TIMEOUT_INTERVAL 2816| | * is equal to TIMEOUT_USECS / 64. 2817| | */ 2818| 0| if (need_timeout) { ------------------ | Branch (2818:9): [True: 0, False: 0] ------------------ 2819| 0| timeout_interval = TIMEOUT_INTERVAL; ------------------ | | 106| 0|#define TIMEOUT_INTERVAL 46875 ------------------ 2820| 0| apr_sleep(timeout_interval); 2821| | 2822| 0| do { 2823| | /* check the status of the subprocesses */ 2824| 0| need_timeout = 0; 2825| 0| for (pc = procs; pc; pc = pc->next) { ------------------ | Branch (2825:30): [True: 0, False: 0] ------------------ 2826| 0| if (pc->kill_how == APR_KILL_AFTER_TIMEOUT) { ------------------ | Branch (2826:21): [True: 0, False: 0] ------------------ 2827| 0| if (apr_proc_wait(pc->proc, NULL, NULL, APR_NOWAIT) ------------------ | Branch (2827:25): [True: 0, False: 0] ------------------ 2828| 0| == APR_CHILD_NOTDONE) ------------------ | | 454| 0|#define APR_CHILD_NOTDONE (APR_OS_START_STATUS + 6) | | ------------------ | | | | 136| 0|#define APR_OS_START_STATUS (APR_OS_START_ERROR + APR_OS_ERRSPACE_SIZE) | | | | ------------------ | | | | | | 117| 0|#define APR_OS_START_ERROR 20000 | | | | ------------------ | | | | #define APR_OS_START_STATUS (APR_OS_START_ERROR + APR_OS_ERRSPACE_SIZE) | | | | ------------------ | | | | | | 123| 0|#define APR_OS_ERRSPACE_SIZE 50000 | | | | ------------------ | | ------------------ ------------------ 2829| 0| need_timeout = 1; /* subprocess is still active */ 2830| 0| else 2831| 0| pc->kill_how = APR_KILL_NEVER; /* subprocess has exited */ 2832| 0| } 2833| 0| } 2834| 0| if (need_timeout) { ------------------ | Branch (2834:17): [True: 0, False: 0] ------------------ 2835| 0| if (timeout_interval >= TIMEOUT_USECS) { ------------------ | | 105| 0|#define TIMEOUT_USECS 3000000 ------------------ | Branch (2835:21): [True: 0, False: 0] ------------------ 2836| 0| break; 2837| 0| } 2838| 0| apr_sleep(timeout_interval); 2839| 0| timeout_interval *= 2; 2840| 0| } 2841| 0| } while (need_timeout); ------------------ | Branch (2841:18): [True: 0, False: 0] ------------------ 2842| 0| } 2843| | 2844| | /* OK, the scripts we just timed out for have had a chance to clean up 2845| | * --- now, just get rid of them, and also clean up the system accounting 2846| | * goop... 2847| | */ 2848| 0| for (pc = procs; pc; pc = pc->next) { ------------------ | Branch (2848:22): [True: 0, False: 0] ------------------ 2849| 0| if (pc->kill_how == APR_KILL_AFTER_TIMEOUT) ------------------ | Branch (2849:13): [True: 0, False: 0] ------------------ 2850| 0| apr_proc_kill(pc->proc, SIGKILL); 2851| 0| } 2852| | 2853| | /* Now wait for all the signaled processes to die */ 2854| 0| for (pc = procs; pc; pc = pc->next) { ------------------ | Branch (2854:22): [True: 0, False: 0] ------------------ 2855| 0| if (pc->kill_how != APR_KILL_NEVER) ------------------ | Branch (2855:13): [True: 0, False: 0] ------------------ 2856| 0| (void)apr_proc_wait(pc->proc, NULL, NULL, APR_WAIT); 2857| 0| } 2858| 0|} apr_pools.c:parent_unlock: 1501| 1.51k|{ 1502| 1.51k| if (mutex) { ------------------ | Branch (1502:9): [True: 0, False: 1.51k] ------------------ 1503| 0| apr_thread_mutex_unlock(mutex); 1504| 0| } 1505| 1.51k|} apr_pools.c:pool_destroy_debug: 1964| 3.03k|{ 1965| 3.03k| pool_clear_debug(pool, file_line); 1966| | 1967| | /* Remove the pool from the parent's child list */ 1968| 3.03k| if (pool->parent != NULL ------------------ | Branch (1968:9): [True: 1.51k, False: 1.51k] ------------------ 1969| 3.03k| && (*pool->ref = pool->sibling) != NULL) { ------------------ | Branch (1969:12): [True: 0, False: 1.51k] ------------------ 1970| 0| pool->sibling->ref = pool->ref; 1971| 0| } 1972| | 1973| | /* Destroy the allocator if the pool owns it */ 1974| 3.03k| if (pool->allocator != NULL ------------------ | Branch (1974:9): [True: 0, False: 3.03k] ------------------ 1975| 3.03k| && apr_allocator_owner_get(pool->allocator) == pool) { ------------------ | Branch (1975:12): [True: 0, False: 0] ------------------ 1976| 0| apr_allocator_destroy(pool->allocator); 1977| 0| } 1978| | 1979| | /* Free the pool itself */ 1980| 3.03k| free(pool); 1981| 3.03k|} apr_pools.c:pool_lock: 1474| 1.51k|{ 1475| 1.51k|#if APR_HAS_THREADS 1476| 1.51k| apr_thread_mutex_lock(pool->mutex); 1477| 1.51k|#endif /* APR_HAS_THREADS */ 1478| 1.51k|} apr_pools.c:pool_unlock: 1482| 1.51k|{ 1483| 1.51k|#if APR_HAS_THREADS 1484| 1.51k| apr_thread_mutex_unlock(pool->mutex); 1485| 1.51k|#endif /* APR_HAS_THREADS */ 1486| 1.51k|} apr_pools.c:psprintf_flush: 2195| 21|{ 2196| 21| struct psprintf_data *ps = (struct psprintf_data *)vbuff; 2197| 21| apr_size_t size; 2198| | 2199| 21| size = ps->vbuff.curpos - ps->mem; 2200| | 2201| 21| ps->size <<= 1; 2202| 21| if ((ps->mem = realloc(ps->mem, ps->size)) == NULL) ------------------ | Branch (2202:9): [True: 0, False: 21] ------------------ 2203| 0| return -1; 2204| | 2205| 21| ps->vbuff.curpos = ps->mem + size; 2206| 21| ps->vbuff.endpos = ps->mem + ps->size - 1; 2207| | 2208| 21| return 0; 2209| 21|} apr_vformatter: 684| 75|{ 685| 75| register char *sp; 686| 75| register char *bep; 687| 75| register int cc = 0; 688| 75| register apr_size_t i; 689| | 690| 75| register char *s = NULL; 691| 75| char *q; 692| 75| apr_size_t s_len = 0; 693| | 694| 75| register apr_size_t min_width = 0; 695| 75| apr_size_t precision = 0; 696| 75| enum { 697| 75| LEFT, RIGHT 698| 75| } adjust; 699| 75| char pad_char; 700| 75| char prefix_char; 701| | 702| 75| double fp_num; 703| 75| apr_int64_t i_quad = 0; 704| 75| apr_uint64_t ui_quad; 705| 75| apr_int32_t i_num = 0; 706| 75| apr_uint32_t ui_num = 0; 707| | 708| 75| char num_buf[NUM_BUF_SIZE]; 709| 75| char char_buf[2]; /* for printing %% and % */ 710| | 711| 75| enum var_type_enum { 712| 75| IS_QUAD, IS_LONG, IS_SHORT, IS_INT 713| 75| }; 714| 75| enum var_type_enum var_type = IS_INT; 715| | 716| | /* 717| | * Flag variables 718| | */ 719| 75| boolean_e alternate_form; 720| 75| boolean_e print_sign; 721| 75| boolean_e print_blank; 722| 75| boolean_e adjust_precision; 723| 75| boolean_e adjust_width; 724| 75| int is_negative; 725| | 726| 75| sp = vbuff->curpos; 727| 75| bep = vbuff->endpos; 728| | 729| 1.49k| while (*fmt) { ------------------ | Branch (729:12): [True: 1.42k, False: 75] ------------------ 730| 1.42k| if (*fmt != '%') { ------------------ | Branch (730:13): [True: 1.31k, False: 107] ------------------ 731| 1.31k| INS_CHAR(*fmt, sp, bep, cc); ------------------ | | 244| 1.31k|#define INS_CHAR(c, sp, bep, cc) \ | | 245| 1.31k|{ \ | | 246| 1.31k| if (sp) { \ | | ------------------ | | | Branch (246:9): [True: 1.31k, False: 0] | | ------------------ | | 247| 1.31k| if (sp >= bep) { \ | | ------------------ | | | Branch (247:13): [True: 0, False: 1.31k] | | ------------------ | | 248| 0| vbuff->curpos = sp; \ | | 249| 0| if (flush_func(vbuff)) \ | | ------------------ | | | Branch (249:17): [True: 0, False: 0] | | ------------------ | | 250| 0| return -1; \ | | 251| 0| sp = vbuff->curpos; \ | | 252| 0| bep = vbuff->endpos; \ | | 253| 0| } \ | | 254| 1.31k| *sp++ = (c); \ | | 255| 1.31k| } \ | | 256| 1.31k| cc++; \ | | 257| 1.31k|} ------------------ 732| 1.31k| } 733| 107| else { 734| | /* 735| | * Default variable settings 736| | */ 737| 107| boolean_e print_something = YES; 738| 107| adjust = RIGHT; 739| 107| alternate_form = print_sign = print_blank = NO; 740| 107| pad_char = ' '; 741| 107| prefix_char = NUL; ------------------ | | 55| 107|#define NUL '\0' ------------------ 742| | 743| 107| fmt++; 744| | 745| | /* 746| | * Try to avoid checking for flags, width or precision 747| | */ 748| 107| if (!apr_islower(*fmt)) { ------------------ | | 216| 107|#define apr_islower(c) (islower(((unsigned char)(c)))) ------------------ | Branch (748:17): [True: 37, False: 70] ------------------ 749| | /* 750| | * Recognize flags: -, #, BLANK, + 751| | */ 752| 37| for (;; fmt++) { 753| 37| if (*fmt == '-') ------------------ | Branch (753:25): [True: 0, False: 37] ------------------ 754| 0| adjust = LEFT; 755| 37| else if (*fmt == '+') ------------------ | Branch (755:30): [True: 0, False: 37] ------------------ 756| 0| print_sign = YES; 757| 37| else if (*fmt == '#') ------------------ | Branch (757:30): [True: 0, False: 37] ------------------ 758| 0| alternate_form = YES; 759| 37| else if (*fmt == ' ') ------------------ | Branch (759:30): [True: 0, False: 37] ------------------ 760| 0| print_blank = YES; 761| 37| else if (*fmt == '0') ------------------ | Branch (761:30): [True: 0, False: 37] ------------------ 762| 0| pad_char = '0'; 763| 37| else 764| 37| break; 765| 37| } 766| | 767| | /* 768| | * Check if a width was specified 769| | */ 770| 37| if (apr_isdigit(*fmt)) { ------------------ | | 212| 37|#define apr_isdigit(c) (isdigit(((unsigned char)(c)))) | | ------------------ | | | Branch (212:24): [True: 0, False: 37] | | ------------------ ------------------ 771| 0| STR_TO_DEC(fmt, min_width); ------------------ | | 262| 0| num = NUM(*str++); \ | | ------------------ | | | | 259| 0|#define NUM(c) (c - '0') | | ------------------ | | 263| 0| while (apr_isdigit(*str)) \ | | ------------------ | | | | 212| 0|#define apr_isdigit(c) (isdigit(((unsigned char)(c)))) | | | | ------------------ | | | | | Branch (212:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 264| 0| { \ | | 265| 0| num *= 10 ; \ | | 266| 0| num += NUM(*str++); \ | | ------------------ | | | | 259| 0|#define NUM(c) (c - '0') | | ------------------ | | 267| 0| } ------------------ 772| 0| adjust_width = YES; 773| 0| } 774| 37| else if (*fmt == '*') { ------------------ | Branch (774:26): [True: 0, False: 37] ------------------ 775| 0| int v = va_arg(ap, int); 776| 0| fmt++; 777| 0| adjust_width = YES; 778| 0| if (v < 0) { ------------------ | Branch (778:25): [True: 0, False: 0] ------------------ 779| 0| adjust = LEFT; 780| 0| min_width = (apr_size_t)(-v); 781| 0| } 782| 0| else 783| 0| min_width = (apr_size_t)v; 784| 0| } 785| 37| else 786| 37| adjust_width = NO; 787| | 788| | /* 789| | * Check if a precision was specified 790| | */ 791| 37| if (*fmt == '.') { ------------------ | Branch (791:21): [True: 37, False: 0] ------------------ 792| 37| adjust_precision = YES; 793| 37| fmt++; 794| 37| if (apr_isdigit(*fmt)) { ------------------ | | 212| 37|#define apr_isdigit(c) (isdigit(((unsigned char)(c)))) | | ------------------ | | | Branch (212:24): [True: 37, False: 0] | | ------------------ ------------------ 795| 37| STR_TO_DEC(fmt, precision); ------------------ | | 262| 37| num = NUM(*str++); \ | | ------------------ | | | | 259| 37|#define NUM(c) (c - '0') | | ------------------ | | 263| 37| while (apr_isdigit(*str)) \ | | ------------------ | | | | 212| 37|#define apr_isdigit(c) (isdigit(((unsigned char)(c)))) | | | | ------------------ | | | | | Branch (212:24): [True: 0, False: 37] | | | | ------------------ | | ------------------ | | 264| 37| { \ | | 265| 0| num *= 10 ; \ | | 266| 0| num += NUM(*str++); \ | | ------------------ | | | | 259| 0|#define NUM(c) (c - '0') | | ------------------ | | 267| 0| } ------------------ 796| 37| } 797| 0| else if (*fmt == '*') { ------------------ | Branch (797:30): [True: 0, False: 0] ------------------ 798| 0| int v = va_arg(ap, int); 799| 0| fmt++; 800| 0| precision = (v < 0) ? 0 : (apr_size_t)v; ------------------ | Branch (800:37): [True: 0, False: 0] ------------------ 801| 0| } 802| 0| else 803| 0| precision = 0; 804| 37| } 805| 0| else 806| 0| adjust_precision = NO; 807| 37| } 808| 70| else 809| 70| adjust_precision = adjust_width = NO; 810| | 811| | /* 812| | * Modifier check. In same cases, APR_OFF_T_FMT can be 813| | * "lld" and APR_INT64_T_FMT can be "ld" (that is, off_t is 814| | * "larger" than int64). Check that case 1st. 815| | * Note that if APR_OFF_T_FMT is "d", 816| | * the first if condition is never true. If APR_INT64_T_FMT 817| | * is "d' then the second if condition is never true. 818| | */ 819| 107| if ((sizeof(APR_OFF_T_FMT) > sizeof(APR_INT64_T_FMT)) && ------------------ | | 604| 107|#define APR_OFF_T_FMT "ld" ------------------ if ((sizeof(APR_OFF_T_FMT) > sizeof(APR_INT64_T_FMT)) && ------------------ | | 610| 107|#define APR_INT64_T_FMT PRId64 ------------------ | Branch (819:17): [Folded - Ignored] ------------------ 820| 107| ((sizeof(APR_OFF_T_FMT) == 4 && ------------------ | | 604| 0|#define APR_OFF_T_FMT "ld" ------------------ | Branch (820:19): [Folded - Ignored] ------------------ 821| 0| fmt[0] == APR_OFF_T_FMT[0] && ------------------ | | 604| 0|#define APR_OFF_T_FMT "ld" ------------------ | Branch (821:18): [True: 0, False: 0] ------------------ 822| 0| fmt[1] == APR_OFF_T_FMT[1]) || ------------------ | | 604| 0|#define APR_OFF_T_FMT "ld" ------------------ | Branch (822:18): [True: 0, False: 0] ------------------ 823| 0| (sizeof(APR_OFF_T_FMT) == 3 && ------------------ | | 604| 0|#define APR_OFF_T_FMT "ld" ------------------ | Branch (823:18): [Folded - Ignored] ------------------ 824| 0| fmt[0] == APR_OFF_T_FMT[0]) || ------------------ | | 604| 0|#define APR_OFF_T_FMT "ld" ------------------ | Branch (824:18): [True: 0, False: 0] ------------------ 825| 0| (sizeof(APR_OFF_T_FMT) > 4 && ------------------ | | 604| 0|#define APR_OFF_T_FMT "ld" ------------------ | Branch (825:18): [Folded - Ignored] ------------------ 826| 0| strncmp(fmt, APR_OFF_T_FMT, ------------------ | | 604| 0|#define APR_OFF_T_FMT "ld" ------------------ | Branch (826:18): [True: 0, False: 0] ------------------ 827| 0| sizeof(APR_OFF_T_FMT) - 2) == 0))) { ------------------ | | 604| 0|#define APR_OFF_T_FMT "ld" ------------------ 828| | /* Need to account for trailing 'd' and null in sizeof() */ 829| 0| var_type = IS_QUAD; 830| 0| fmt += (sizeof(APR_OFF_T_FMT) - 2); ------------------ | | 604| 0|#define APR_OFF_T_FMT "ld" ------------------ 831| 0| } 832| 107| else if ((sizeof(APR_INT64_T_FMT) == 4 && ------------------ | | 610| 107|#define APR_INT64_T_FMT PRId64 ------------------ | Branch (832:23): [Folded - Ignored] ------------------ 833| 107| fmt[0] == APR_INT64_T_FMT[0] && ------------------ | | 610| 0|#define APR_INT64_T_FMT PRId64 ------------------ | Branch (833:18): [True: 0, False: 0] ------------------ 834| 107| fmt[1] == APR_INT64_T_FMT[1]) || ------------------ | | 610| 0|#define APR_INT64_T_FMT PRId64 ------------------ | Branch (834:18): [True: 0, False: 0] ------------------ 835| 107| (sizeof(APR_INT64_T_FMT) == 3 && ------------------ | | 610| 107|#define APR_INT64_T_FMT PRId64 ------------------ | Branch (835:18): [Folded - Ignored] ------------------ 836| 107| fmt[0] == APR_INT64_T_FMT[0]) || ------------------ | | 610| 107|#define APR_INT64_T_FMT PRId64 ------------------ | Branch (836:18): [True: 0, False: 107] ------------------ 837| 107| (sizeof(APR_INT64_T_FMT) > 4 && ------------------ | | 610| 0|#define APR_INT64_T_FMT PRId64 ------------------ | Branch (837:18): [Folded - Ignored] ------------------ 838| 0| strncmp(fmt, APR_INT64_T_FMT, ------------------ | | 610| 0|#define APR_INT64_T_FMT PRId64 ------------------ | Branch (838:18): [True: 0, False: 0] ------------------ 839| 0| sizeof(APR_INT64_T_FMT) - 2) == 0)) { ------------------ | | 610| 0|#define APR_INT64_T_FMT PRId64 ------------------ 840| | /* Need to account for trailing 'd' and null in sizeof() */ 841| 0| var_type = IS_QUAD; 842| 0| fmt += (sizeof(APR_INT64_T_FMT) - 2); ------------------ | | 610| 0|#define APR_INT64_T_FMT PRId64 ------------------ 843| 0| } 844| 107| else if (*fmt == 'q') { ------------------ | Branch (844:22): [True: 0, False: 107] ------------------ 845| 0| var_type = IS_QUAD; 846| 0| fmt++; 847| 0| } 848| 107| else if (*fmt == 'l') { ------------------ | Branch (848:22): [True: 0, False: 107] ------------------ 849| 0| var_type = IS_LONG; 850| 0| fmt++; 851| 0| } 852| 107| else if (*fmt == 'h') { ------------------ | Branch (852:22): [True: 0, False: 107] ------------------ 853| 0| var_type = IS_SHORT; 854| 0| fmt++; 855| 0| } 856| 107| else { 857| 107| var_type = IS_INT; 858| 107| } 859| | 860| | /* 861| | * Argument extraction and printing. 862| | * First we determine the argument type. 863| | * Then, we convert the argument to a string. 864| | * On exit from the switch, s points to the string that 865| | * must be printed, s_len has the length of the string 866| | * The precision requirements, if any, are reflected in s_len. 867| | * 868| | * NOTE: pad_char may be set to '0' because of the 0 flag. 869| | * It is reset to ' ' by non-numeric formats 870| | */ 871| 107| switch (*fmt) { 872| 0| case 'u': ------------------ | Branch (872:13): [True: 0, False: 107] ------------------ 873| 0| if (var_type == IS_QUAD) { ------------------ | Branch (873:21): [True: 0, False: 0] ------------------ 874| 0| i_quad = va_arg(ap, apr_uint64_t); 875| 0| s = conv_10_quad(i_quad, 1, &is_negative, 876| 0| &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 877| 0| } 878| 0| else { 879| 0| if (var_type == IS_LONG) ------------------ | Branch (879:25): [True: 0, False: 0] ------------------ 880| 0| i_num = (apr_int32_t) va_arg(ap, apr_uint32_t); 881| 0| else if (var_type == IS_SHORT) ------------------ | Branch (881:30): [True: 0, False: 0] ------------------ 882| 0| i_num = (apr_int32_t) (unsigned short) va_arg(ap, unsigned int); 883| 0| else 884| 0| i_num = (apr_int32_t) va_arg(ap, unsigned int); 885| 0| s = conv_10(i_num, 1, &is_negative, 886| 0| &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 887| 0| } 888| 0| FIX_PRECISION(adjust_precision, precision, s, s_len); ------------------ | | 280| 0| if (adjust) { \ | | ------------------ | | | Branch (280:9): [True: 0, False: 0] | | ------------------ | | 281| 0| apr_size_t p = (precision + 1 < NUM_BUF_SIZE) \ | | ------------------ | | | | 69| 0|#define NUM_BUF_SIZE 512 | | ------------------ | | | Branch (281:24): [True: 0, False: 0] | | ------------------ | | 282| 0| ? precision : NUM_BUF_SIZE - 1; \ | | ------------------ | | | | 69| 0|#define NUM_BUF_SIZE 512 | | ------------------ | | 283| 0| while (s_len < p) \ | | ------------------ | | | Branch (283:16): [True: 0, False: 0] | | ------------------ | | 284| 0| { \ | | 285| 0| *--s = '0'; \ | | 286| 0| s_len++; \ | | 287| 0| } \ | | 288| 0| } ------------------ 889| 0| break; 890| | 891| 0| case 'd': ------------------ | Branch (891:13): [True: 0, False: 107] ------------------ 892| 0| case 'i': ------------------ | Branch (892:13): [True: 0, False: 107] ------------------ 893| 0| if (var_type == IS_QUAD) { ------------------ | Branch (893:21): [True: 0, False: 0] ------------------ 894| 0| i_quad = va_arg(ap, apr_int64_t); 895| 0| s = conv_10_quad(i_quad, 0, &is_negative, 896| 0| &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 897| 0| } 898| 0| else { 899| 0| if (var_type == IS_LONG) ------------------ | Branch (899:25): [True: 0, False: 0] ------------------ 900| 0| i_num = va_arg(ap, apr_int32_t); 901| 0| else if (var_type == IS_SHORT) ------------------ | Branch (901:30): [True: 0, False: 0] ------------------ 902| 0| i_num = (short) va_arg(ap, int); 903| 0| else 904| 0| i_num = va_arg(ap, int); 905| 0| s = conv_10(i_num, 0, &is_negative, 906| 0| &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 907| 0| } 908| 0| FIX_PRECISION(adjust_precision, precision, s, s_len); ------------------ | | 280| 0| if (adjust) { \ | | ------------------ | | | Branch (280:9): [True: 0, False: 0] | | ------------------ | | 281| 0| apr_size_t p = (precision + 1 < NUM_BUF_SIZE) \ | | ------------------ | | | | 69| 0|#define NUM_BUF_SIZE 512 | | ------------------ | | | Branch (281:24): [True: 0, False: 0] | | ------------------ | | 282| 0| ? precision : NUM_BUF_SIZE - 1; \ | | ------------------ | | | | 69| 0|#define NUM_BUF_SIZE 512 | | ------------------ | | 283| 0| while (s_len < p) \ | | ------------------ | | | Branch (283:16): [True: 0, False: 0] | | ------------------ | | 284| 0| { \ | | 285| 0| *--s = '0'; \ | | 286| 0| s_len++; \ | | 287| 0| } \ | | 288| 0| } ------------------ 909| | 910| 0| if (is_negative) ------------------ | Branch (910:21): [True: 0, False: 0] ------------------ 911| 0| prefix_char = '-'; 912| 0| else if (print_sign) ------------------ | Branch (912:26): [True: 0, False: 0] ------------------ 913| 0| prefix_char = '+'; 914| 0| else if (print_blank) ------------------ | Branch (914:26): [True: 0, False: 0] ------------------ 915| 0| prefix_char = ' '; 916| 0| break; 917| | 918| | 919| 0| case 'o': ------------------ | Branch (919:13): [True: 0, False: 107] ------------------ 920| 0| if (var_type == IS_QUAD) { ------------------ | Branch (920:21): [True: 0, False: 0] ------------------ 921| 0| ui_quad = va_arg(ap, apr_uint64_t); 922| 0| s = conv_p2_quad(ui_quad, 3, *fmt, 923| 0| &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 924| 0| } 925| 0| else { 926| 0| if (var_type == IS_LONG) ------------------ | Branch (926:25): [True: 0, False: 0] ------------------ 927| 0| ui_num = va_arg(ap, apr_uint32_t); 928| 0| else if (var_type == IS_SHORT) ------------------ | Branch (928:30): [True: 0, False: 0] ------------------ 929| 0| ui_num = (unsigned short) va_arg(ap, unsigned int); 930| 0| else 931| 0| ui_num = va_arg(ap, unsigned int); 932| 0| s = conv_p2(ui_num, 3, *fmt, 933| 0| &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 934| 0| } 935| 0| FIX_PRECISION(adjust_precision, precision, s, s_len); ------------------ | | 280| 0| if (adjust) { \ | | ------------------ | | | Branch (280:9): [True: 0, False: 0] | | ------------------ | | 281| 0| apr_size_t p = (precision + 1 < NUM_BUF_SIZE) \ | | ------------------ | | | | 69| 0|#define NUM_BUF_SIZE 512 | | ------------------ | | | Branch (281:24): [True: 0, False: 0] | | ------------------ | | 282| 0| ? precision : NUM_BUF_SIZE - 1; \ | | ------------------ | | | | 69| 0|#define NUM_BUF_SIZE 512 | | ------------------ | | 283| 0| while (s_len < p) \ | | ------------------ | | | Branch (283:16): [True: 0, False: 0] | | ------------------ | | 284| 0| { \ | | 285| 0| *--s = '0'; \ | | 286| 0| s_len++; \ | | 287| 0| } \ | | 288| 0| } ------------------ 936| 0| if (alternate_form && *s != '0') { ------------------ | Branch (936:21): [True: 0, False: 0] | Branch (936:39): [True: 0, False: 0] ------------------ 937| 0| *--s = '0'; 938| 0| s_len++; 939| 0| } 940| 0| break; 941| | 942| | 943| 0| case 'x': ------------------ | Branch (943:13): [True: 0, False: 107] ------------------ 944| 37| case 'X': ------------------ | Branch (944:13): [True: 37, False: 70] ------------------ 945| 37| if (var_type == IS_QUAD) { ------------------ | Branch (945:21): [True: 0, False: 37] ------------------ 946| 0| ui_quad = va_arg(ap, apr_uint64_t); 947| 0| s = conv_p2_quad(ui_quad, 4, *fmt, 948| 0| &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 949| 0| } 950| 37| else { 951| 37| if (var_type == IS_LONG) ------------------ | Branch (951:25): [True: 0, False: 37] ------------------ 952| 0| ui_num = va_arg(ap, apr_uint32_t); 953| 37| else if (var_type == IS_SHORT) ------------------ | Branch (953:30): [True: 0, False: 37] ------------------ 954| 0| ui_num = (unsigned short) va_arg(ap, unsigned int); 955| 37| else 956| 37| ui_num = va_arg(ap, unsigned int); 957| 37| s = conv_p2(ui_num, 4, *fmt, 958| 37| &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 37|#define NUM_BUF_SIZE 512 ------------------ 959| 37| } 960| 37| FIX_PRECISION(adjust_precision, precision, s, s_len); ------------------ | | 280| 37| if (adjust) { \ | | ------------------ | | | Branch (280:9): [True: 37, False: 0] | | ------------------ | | 281| 37| apr_size_t p = (precision + 1 < NUM_BUF_SIZE) \ | | ------------------ | | | | 69| 37|#define NUM_BUF_SIZE 512 | | ------------------ | | | Branch (281:24): [True: 37, False: 0] | | ------------------ | | 282| 37| ? precision : NUM_BUF_SIZE - 1; \ | | ------------------ | | | | 69| 0|#define NUM_BUF_SIZE 512 | | ------------------ | | 283| 62| while (s_len < p) \ | | ------------------ | | | Branch (283:16): [True: 25, False: 37] | | ------------------ | | 284| 37| { \ | | 285| 25| *--s = '0'; \ | | 286| 25| s_len++; \ | | 287| 25| } \ | | 288| 37| } ------------------ 961| 37| if (alternate_form && ui_num != 0) { ------------------ | Branch (961:21): [True: 0, False: 37] | Branch (961:39): [True: 0, False: 0] ------------------ 962| 0| *--s = *fmt; /* 'x' or 'X' */ 963| 0| *--s = '0'; 964| 0| s_len += 2; 965| 0| } 966| 37| break; 967| | 968| | 969| 64| case 's': ------------------ | Branch (969:13): [True: 64, False: 43] ------------------ 970| 64| s = va_arg(ap, char *); 971| 64| if (s != NULL) { ------------------ | Branch (971:21): [True: 64, False: 0] ------------------ 972| 64| if (!adjust_precision) { ------------------ | Branch (972:25): [True: 64, False: 0] ------------------ 973| 64| s_len = strlen(s); 974| 64| } 975| 0| else { 976| | /* From the C library standard in section 7.9.6.1: 977| | * ...if the precision is specified, no more then 978| | * that many characters are written. If the 979| | * precision is not specified or is greater 980| | * than the size of the array, the array shall 981| | * contain a null character. 982| | * 983| | * My reading is is precision is specified and 984| | * is less then or equal to the size of the 985| | * array, no null character is required. So 986| | * we can't do a strlen. 987| | * 988| | * This figures out the length of the string 989| | * up to the precision. Once it's long enough 990| | * for the specified precision, we don't care 991| | * anymore. 992| | * 993| | * NOTE: you must do the length comparison 994| | * before the check for the null character. 995| | * Otherwise, you'll check one beyond the 996| | * last valid character. 997| | */ 998| 0| const char *walk; 999| | 1000| 0| for (walk = s, s_len = 0; 1001| 0| (s_len < precision) && (*walk != '\0'); ------------------ | Branch (1001:30): [True: 0, False: 0] | Branch (1001:53): [True: 0, False: 0] ------------------ 1002| 0| ++walk, ++s_len); 1003| 0| } 1004| 64| } 1005| 0| else { 1006| 0| s = S_NULL; ------------------ | | 58| 0|#define S_NULL ((char *)null_string) ------------------ 1007| 0| s_len = S_NULL_LEN; ------------------ | | 59| 0|#define S_NULL_LEN 6 ------------------ 1008| 0| } 1009| 64| pad_char = ' '; 1010| 64| break; 1011| | 1012| | 1013| 0| case 'f': ------------------ | Branch (1013:13): [True: 0, False: 107] ------------------ 1014| 0| case 'e': ------------------ | Branch (1014:13): [True: 0, False: 107] ------------------ 1015| 0| case 'E': ------------------ | Branch (1015:13): [True: 0, False: 107] ------------------ 1016| 0| fp_num = va_arg(ap, double); 1017| | /* 1018| | * We use &num_buf[ 1 ], so that we have room for the sign 1019| | */ 1020| 0| s = NULL; 1021| 0|#ifdef HAVE_ISNAN 1022| 0| if (isnan(fp_num)) { 1023| 0| s = "nan"; 1024| 0| s_len = 3; 1025| 0| } 1026| 0|#endif 1027| 0|#ifdef HAVE_ISINF 1028| 0| if (!s && isinf(fp_num)) { ------------------ | Branch (1028:21): [True: 0, False: 0] ------------------ 1029| 0| s = "inf"; 1030| 0| s_len = 3; 1031| 0| } 1032| 0|#endif 1033| 0| if (!s) { ------------------ | Branch (1033:21): [True: 0, False: 0] ------------------ 1034| 0| s = conv_fp(*fmt, fp_num, alternate_form, 1035| 0| (int)((adjust_precision == NO) ? FLOAT_DIGITS : precision), ------------------ | | 61| 0|#define FLOAT_DIGITS 6 ------------------ | Branch (1035:39): [True: 0, False: 0] ------------------ 1036| 0| &is_negative, &num_buf[1], &s_len); 1037| 0| if (is_negative) ------------------ | Branch (1037:25): [True: 0, False: 0] ------------------ 1038| 0| prefix_char = '-'; 1039| 0| else if (print_sign) ------------------ | Branch (1039:30): [True: 0, False: 0] ------------------ 1040| 0| prefix_char = '+'; 1041| 0| else if (print_blank) ------------------ | Branch (1041:30): [True: 0, False: 0] ------------------ 1042| 0| prefix_char = ' '; 1043| 0| } 1044| 0| break; 1045| | 1046| | 1047| 0| case 'g': ------------------ | Branch (1047:13): [True: 0, False: 107] ------------------ 1048| 0| case 'G': ------------------ | Branch (1048:13): [True: 0, False: 107] ------------------ 1049| 0| if (adjust_precision == NO) ------------------ | Branch (1049:21): [True: 0, False: 0] ------------------ 1050| 0| precision = FLOAT_DIGITS; ------------------ | | 61| 0|#define FLOAT_DIGITS 6 ------------------ 1051| 0| else if (precision == 0) ------------------ | Branch (1051:26): [True: 0, False: 0] ------------------ 1052| 0| precision = 1; 1053| | /* 1054| | * * We use &num_buf[ 1 ], so that we have room for the sign 1055| | */ 1056| 0| s = apr_gcvt(va_arg(ap, double), (int) precision, &num_buf[1], 1057| 0| alternate_form); 1058| 0| if (*s == '-') ------------------ | Branch (1058:21): [True: 0, False: 0] ------------------ 1059| 0| prefix_char = *s++; 1060| 0| else if (print_sign) ------------------ | Branch (1060:26): [True: 0, False: 0] ------------------ 1061| 0| prefix_char = '+'; 1062| 0| else if (print_blank) ------------------ | Branch (1062:26): [True: 0, False: 0] ------------------ 1063| 0| prefix_char = ' '; 1064| | 1065| 0| s_len = strlen(s); 1066| | 1067| 0| if (alternate_form && (q = strchr(s, '.')) == NULL) { ------------------ | Branch (1067:21): [True: 0, False: 0] | Branch (1067:39): [True: 0, False: 0] ------------------ 1068| 0| s[s_len++] = '.'; 1069| 0| s[s_len] = '\0'; /* delimit for following strchr() */ 1070| 0| } 1071| 0| if (*fmt == 'G' && (q = strchr(s, 'e')) != NULL) ------------------ | Branch (1071:21): [True: 0, False: 0] | Branch (1071:36): [True: 0, False: 0] ------------------ 1072| 0| *q = 'E'; 1073| 0| break; 1074| | 1075| | 1076| 6| case 'c': ------------------ | Branch (1076:13): [True: 6, False: 101] ------------------ 1077| 6| char_buf[0] = (char) (va_arg(ap, int)); 1078| 6| s = &char_buf[0]; 1079| 6| s_len = 1; 1080| 6| pad_char = ' '; 1081| 6| break; 1082| | 1083| | 1084| 0| case '%': ------------------ | Branch (1084:13): [True: 0, False: 107] ------------------ 1085| 0| char_buf[0] = '%'; 1086| 0| s = &char_buf[0]; 1087| 0| s_len = 1; 1088| 0| pad_char = ' '; 1089| 0| break; 1090| | 1091| | 1092| 0| case 'n': ------------------ | Branch (1092:13): [True: 0, False: 107] ------------------ 1093| 0| if (var_type == IS_QUAD) ------------------ | Branch (1093:21): [True: 0, False: 0] ------------------ 1094| 0| *(va_arg(ap, apr_int64_t *)) = cc; 1095| 0| else if (var_type == IS_LONG) ------------------ | Branch (1095:26): [True: 0, False: 0] ------------------ 1096| 0| *(va_arg(ap, long *)) = cc; 1097| 0| else if (var_type == IS_SHORT) ------------------ | Branch (1097:26): [True: 0, False: 0] ------------------ 1098| 0| *(va_arg(ap, short *)) = cc; 1099| 0| else 1100| 0| *(va_arg(ap, int *)) = cc; 1101| 0| print_something = NO; 1102| 0| break; 1103| | 1104| | /* 1105| | * This is where we extend the printf format, with a second 1106| | * type specifier 1107| | */ 1108| 0| case 'p': ------------------ | Branch (1108:13): [True: 0, False: 107] ------------------ 1109| 0| switch(*++fmt) { 1110| | /* 1111| | * If the pointer size is equal to or smaller than the size 1112| | * of the largest unsigned int, we convert the pointer to a 1113| | * hex number, otherwise we print "%p" to indicate that we 1114| | * don't handle "%p". 1115| | */ 1116| 0| case 'p': ------------------ | Branch (1116:17): [True: 0, False: 0] ------------------ 1117| 0|#if APR_SIZEOF_VOIDP == 8 1118| 0| if (sizeof(void *) <= sizeof(apr_uint64_t)) { ------------------ | Branch (1118:25): [Folded - Ignored] ------------------ 1119| 0| ui_quad = (apr_uint64_t) va_arg(ap, void *); 1120| 0| s = conv_p2_quad(ui_quad, 4, 'x', 1121| 0| &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 1122| 0| } 1123| |#else 1124| | if (sizeof(void *) <= sizeof(apr_uint32_t)) { 1125| | ui_num = (apr_uint32_t) va_arg(ap, void *); 1126| | s = conv_p2(ui_num, 4, 'x', 1127| | &num_buf[NUM_BUF_SIZE], &s_len); 1128| | } 1129| |#endif 1130| 0| else { 1131| 0| s = "%p"; 1132| 0| s_len = 2; 1133| 0| prefix_char = NUL; ------------------ | | 55| 0|#define NUL '\0' ------------------ 1134| 0| } 1135| 0| pad_char = ' '; 1136| 0| break; 1137| | 1138| | /* print an apr_sockaddr_t as a.b.c.d:port */ 1139| 0| case 'I': ------------------ | Branch (1139:17): [True: 0, False: 0] ------------------ 1140| 0| { 1141| 0| apr_sockaddr_t *sa; 1142| | 1143| 0| sa = va_arg(ap, apr_sockaddr_t *); 1144| 0| if (sa != NULL) { ------------------ | Branch (1144:25): [True: 0, False: 0] ------------------ 1145| 0| s = conv_apr_sockaddr(sa, &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 1146| 0| if (adjust_precision && precision < s_len) ------------------ | Branch (1146:29): [True: 0, False: 0] | Branch (1146:49): [True: 0, False: 0] ------------------ 1147| 0| s_len = precision; 1148| 0| } 1149| 0| else { 1150| 0| s = S_NULL; ------------------ | | 58| 0|#define S_NULL ((char *)null_string) ------------------ 1151| 0| s_len = S_NULL_LEN; ------------------ | | 59| 0|#define S_NULL_LEN 6 ------------------ 1152| 0| } 1153| 0| pad_char = ' '; 1154| 0| } 1155| 0| break; 1156| | 1157| | /* print a struct in_addr as a.b.c.d */ 1158| 0| case 'A': ------------------ | Branch (1158:17): [True: 0, False: 0] ------------------ 1159| 0| { 1160| 0| struct in_addr *ia; 1161| | 1162| 0| ia = va_arg(ap, struct in_addr *); 1163| 0| if (ia != NULL) { ------------------ | Branch (1163:25): [True: 0, False: 0] ------------------ 1164| 0| s = conv_in_addr(ia, &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 1165| 0| if (adjust_precision && precision < s_len) ------------------ | Branch (1165:29): [True: 0, False: 0] | Branch (1165:49): [True: 0, False: 0] ------------------ 1166| 0| s_len = precision; 1167| 0| } 1168| 0| else { 1169| 0| s = S_NULL; ------------------ | | 58| 0|#define S_NULL ((char *)null_string) ------------------ 1170| 0| s_len = S_NULL_LEN; ------------------ | | 59| 0|#define S_NULL_LEN 6 ------------------ 1171| 0| } 1172| 0| pad_char = ' '; 1173| 0| } 1174| 0| break; 1175| | 1176| | /* print the error for an apr_status_t */ 1177| 0| case 'm': ------------------ | Branch (1177:17): [True: 0, False: 0] ------------------ 1178| 0| { 1179| 0| apr_status_t *mrv; 1180| | 1181| 0| mrv = va_arg(ap, apr_status_t *); 1182| 0| if (mrv != NULL) { ------------------ | Branch (1182:25): [True: 0, False: 0] ------------------ 1183| 0| s = apr_strerror(*mrv, num_buf, NUM_BUF_SIZE-1); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 1184| 0| s_len = strlen(s); 1185| 0| } 1186| 0| else { 1187| 0| s = S_NULL; ------------------ | | 58| 0|#define S_NULL ((char *)null_string) ------------------ 1188| 0| s_len = S_NULL_LEN; ------------------ | | 59| 0|#define S_NULL_LEN 6 ------------------ 1189| 0| } 1190| 0| pad_char = ' '; 1191| 0| } 1192| 0| break; 1193| | 1194| | /* print the tag for an apr_pool_t */ 1195| 0| case 'g': ------------------ | Branch (1195:17): [True: 0, False: 0] ------------------ 1196| 0| { 1197| 0| apr_pool_t *prv; 1198| | 1199| 0| prv = va_arg(ap, apr_pool_t *); 1200| 0| if (prv != NULL) { ------------------ | Branch (1200:25): [True: 0, False: 0] ------------------ 1201| 0| s = (char *)apr_pool_get_tag(prv); 1202| 0| if (!s) s = "(untagged)"; ------------------ | Branch (1202:29): [True: 0, False: 0] ------------------ 1203| 0| s_len = strlen(s); 1204| 0| } 1205| 0| else { 1206| 0| s = S_NULL; ------------------ | | 58| 0|#define S_NULL ((char *)null_string) ------------------ 1207| 0| s_len = S_NULL_LEN; ------------------ | | 59| 0|#define S_NULL_LEN 6 ------------------ 1208| 0| } 1209| 0| pad_char = ' '; 1210| 0| } 1211| 0| break; 1212| | 1213| 0| case 'T': ------------------ | Branch (1213:17): [True: 0, False: 0] ------------------ 1214| 0|#if APR_HAS_THREADS 1215| 0| { 1216| 0| apr_os_thread_t *tid; 1217| | 1218| 0| tid = va_arg(ap, apr_os_thread_t *); 1219| 0| if (tid != NULL) { ------------------ | Branch (1219:25): [True: 0, False: 0] ------------------ 1220| 0| s = conv_os_thread_t(tid, &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 1221| 0| if (adjust_precision && precision < s_len) ------------------ | Branch (1221:29): [True: 0, False: 0] | Branch (1221:49): [True: 0, False: 0] ------------------ 1222| 0| s_len = precision; 1223| 0| } 1224| 0| else { 1225| 0| s = S_NULL; ------------------ | | 58| 0|#define S_NULL ((char *)null_string) ------------------ 1226| 0| s_len = S_NULL_LEN; ------------------ | | 59| 0|#define S_NULL_LEN 6 ------------------ 1227| 0| } 1228| 0| pad_char = ' '; 1229| 0| } 1230| |#else 1231| | char_buf[0] = '0'; 1232| | s = &char_buf[0]; 1233| | s_len = 1; 1234| | pad_char = ' '; 1235| |#endif 1236| 0| break; 1237| | 1238| 0| case 't': ------------------ | Branch (1238:17): [True: 0, False: 0] ------------------ 1239| 0|#if APR_HAS_THREADS 1240| 0| { 1241| 0| apr_os_thread_t *tid; 1242| | 1243| 0| tid = va_arg(ap, apr_os_thread_t *); 1244| 0| if (tid != NULL) { ------------------ | Branch (1244:25): [True: 0, False: 0] ------------------ 1245| 0| s = conv_os_thread_t_hex(tid, &num_buf[NUM_BUF_SIZE], &s_len); ------------------ | | 69| 0|#define NUM_BUF_SIZE 512 ------------------ 1246| 0| if (adjust_precision && precision < s_len) ------------------ | Branch (1246:29): [True: 0, False: 0] | Branch (1246:49): [True: 0, False: 0] ------------------ 1247| 0| s_len = precision; 1248| 0| } 1249| 0| else { 1250| 0| s = S_NULL; ------------------ | | 58| 0|#define S_NULL ((char *)null_string) ------------------ 1251| 0| s_len = S_NULL_LEN; ------------------ | | 59| 0|#define S_NULL_LEN 6 ------------------ 1252| 0| } 1253| 0| pad_char = ' '; 1254| 0| } 1255| |#else 1256| | char_buf[0] = '0'; 1257| | s = &char_buf[0]; 1258| | s_len = 1; 1259| | pad_char = ' '; 1260| |#endif 1261| 0| break; 1262| | 1263| 0| case 'B': ------------------ | Branch (1263:17): [True: 0, False: 0] ------------------ 1264| 0| case 'F': ------------------ | Branch (1264:17): [True: 0, False: 0] ------------------ 1265| 0| case 'S': ------------------ | Branch (1265:17): [True: 0, False: 0] ------------------ 1266| 0| { 1267| 0| char buf[5]; 1268| 0| apr_off_t size = 0; 1269| | 1270| 0| if (*fmt == 'B') { ------------------ | Branch (1270:25): [True: 0, False: 0] ------------------ 1271| 0| apr_uint32_t *arg = va_arg(ap, apr_uint32_t *); 1272| 0| size = (arg) ? *arg : 0; ------------------ | Branch (1272:32): [True: 0, False: 0] ------------------ 1273| 0| } 1274| 0| else if (*fmt == 'F') { ------------------ | Branch (1274:30): [True: 0, False: 0] ------------------ 1275| 0| apr_off_t *arg = va_arg(ap, apr_off_t *); 1276| 0| size = (arg) ? *arg : 0; ------------------ | Branch (1276:32): [True: 0, False: 0] ------------------ 1277| 0| } 1278| 0| else { 1279| 0| apr_size_t *arg = va_arg(ap, apr_size_t *); 1280| 0| size = (arg) ? *arg : 0; ------------------ | Branch (1280:32): [True: 0, False: 0] ------------------ 1281| 0| } 1282| | 1283| 0| s = apr_strfsize(size, buf); 1284| 0| s_len = strlen(s); 1285| 0| pad_char = ' '; 1286| 0| } 1287| 0| break; 1288| | 1289| 0| case NUL: ------------------ | | 55| 0|#define NUL '\0' ------------------ | Branch (1289:17): [True: 0, False: 0] ------------------ 1290| | /* if %p ends the string, oh well ignore it */ 1291| 0| continue; 1292| | 1293| 0| default: ------------------ | Branch (1293:17): [True: 0, False: 0] ------------------ 1294| 0| s = "bogus %p"; 1295| 0| s_len = 8; 1296| 0| prefix_char = NUL; ------------------ | | 55| 0|#define NUL '\0' ------------------ 1297| 0| (void)va_arg(ap, void *); /* skip the bogus argument on the stack */ 1298| 0| break; 1299| 0| } 1300| 0| break; 1301| | 1302| 0| case NUL: ------------------ | | 55| 0|#define NUL '\0' ------------------ | Branch (1302:13): [True: 0, False: 107] ------------------ 1303| | /* 1304| | * The last character of the format string was %. 1305| | * We ignore it. 1306| | */ 1307| 0| continue; 1308| | 1309| | 1310| | /* 1311| | * The default case is for unrecognized %'s. 1312| | * We print % to help the user identify what 1313| | * option is not understood. 1314| | * This is also useful in case the user wants to pass 1315| | * the output of format_converter to another function 1316| | * that understands some other % (like syslog). 1317| | * Note that we can't point s inside fmt because the 1318| | * unknown could be preceded by width etc. 1319| | */ 1320| 0| default: ------------------ | Branch (1320:13): [True: 0, False: 107] ------------------ 1321| 0| char_buf[0] = '%'; 1322| 0| char_buf[1] = *fmt; 1323| 0| s = char_buf; 1324| 0| s_len = 2; 1325| 0| pad_char = ' '; 1326| 0| break; 1327| 107| } 1328| | 1329| 107| if (prefix_char != NUL && s != S_NULL && s != char_buf) { ------------------ | | 55| 214|#define NUL '\0' ------------------ if (prefix_char != NUL && s != S_NULL && s != char_buf) { ------------------ | | 58| 107|#define S_NULL ((char *)null_string) ------------------ | Branch (1329:17): [True: 0, False: 107] | Branch (1329:39): [True: 0, False: 0] | Branch (1329:54): [True: 0, False: 0] ------------------ 1330| 0| *--s = prefix_char; 1331| 0| s_len++; 1332| 0| } 1333| | 1334| 107| if (adjust_width && adjust == RIGHT && min_width > s_len) { ------------------ | Branch (1334:17): [True: 0, False: 107] | Branch (1334:33): [True: 0, False: 0] | Branch (1334:52): [True: 0, False: 0] ------------------ 1335| 0| if (pad_char == '0' && prefix_char != NUL) { ------------------ | | 55| 0|#define NUL '\0' ------------------ | Branch (1335:21): [True: 0, False: 0] | Branch (1335:40): [True: 0, False: 0] ------------------ 1336| 0| INS_CHAR(*s, sp, bep, cc); ------------------ | | 244| 0|#define INS_CHAR(c, sp, bep, cc) \ | | 245| 0|{ \ | | 246| 0| if (sp) { \ | | ------------------ | | | Branch (246:9): [True: 0, False: 0] | | ------------------ | | 247| 0| if (sp >= bep) { \ | | ------------------ | | | Branch (247:13): [True: 0, False: 0] | | ------------------ | | 248| 0| vbuff->curpos = sp; \ | | 249| 0| if (flush_func(vbuff)) \ | | ------------------ | | | Branch (249:17): [True: 0, False: 0] | | ------------------ | | 250| 0| return -1; \ | | 251| 0| sp = vbuff->curpos; \ | | 252| 0| bep = vbuff->endpos; \ | | 253| 0| } \ | | 254| 0| *sp++ = (c); \ | | 255| 0| } \ | | 256| 0| cc++; \ | | 257| 0|} ------------------ 1337| 0| s++; 1338| 0| s_len--; 1339| 0| min_width--; 1340| 0| } 1341| 0| PAD(min_width, s_len, pad_char); ------------------ | | 294| 0|#define PAD(width, len, ch) \ | | 295| 0|do \ | | 296| 0|{ \ | | 297| 0| INS_CHAR(ch, sp, bep, cc); \ | | ------------------ | | | | 244| 0|#define INS_CHAR(c, sp, bep, cc) \ | | | | 245| 0|{ \ | | | | 246| 0| if (sp) { \ | | | | ------------------ | | | | | Branch (246:9): [True: 0, False: 0] | | | | ------------------ | | | | 247| 0| if (sp >= bep) { \ | | | | ------------------ | | | | | Branch (247:13): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| vbuff->curpos = sp; \ | | | | 249| 0| if (flush_func(vbuff)) \ | | | | ------------------ | | | | | Branch (249:17): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| return -1; \ | | | | 251| 0| sp = vbuff->curpos; \ | | | | 252| 0| bep = vbuff->endpos; \ | | | | 253| 0| } \ | | | | 254| 0| *sp++ = (c); \ | | | | 255| 0| } \ | | | | 256| 0| cc++; \ | | | | 257| 0|} | | ------------------ | | 298| 0| width--; \ | | 299| 0|} \ | | 300| 0|while (width > len) | | ------------------ | | | Branch (300:8): [True: 0, False: 0] | | ------------------ ------------------ 1342| 0| } 1343| | 1344| | /* 1345| | * Print the string s. 1346| | */ 1347| 107| if (print_something == YES) { ------------------ | Branch (1347:17): [True: 107, False: 0] ------------------ 1348| 2.48k| for (i = s_len; i != 0; i--) { ------------------ | Branch (1348:33): [True: 2.38k, False: 107] ------------------ 1349| 2.38k| INS_CHAR(*s, sp, bep, cc); ------------------ | | 244| 2.38k|#define INS_CHAR(c, sp, bep, cc) \ | | 245| 2.38k|{ \ | | 246| 2.38k| if (sp) { \ | | ------------------ | | | Branch (246:9): [True: 2.38k, False: 0] | | ------------------ | | 247| 2.38k| if (sp >= bep) { \ | | ------------------ | | | Branch (247:13): [True: 21, False: 2.36k] | | ------------------ | | 248| 21| vbuff->curpos = sp; \ | | 249| 21| if (flush_func(vbuff)) \ | | ------------------ | | | Branch (249:17): [True: 0, False: 21] | | ------------------ | | 250| 21| return -1; \ | | 251| 21| sp = vbuff->curpos; \ | | 252| 21| bep = vbuff->endpos; \ | | 253| 21| } \ | | 254| 2.38k| *sp++ = (c); \ | | 255| 2.38k| } \ | | 256| 2.38k| cc++; \ | | 257| 2.38k|} ------------------ 1350| 2.38k| s++; 1351| 2.38k| } 1352| 107| } 1353| | 1354| 107| if (adjust_width && adjust == LEFT && min_width > s_len) ------------------ | Branch (1354:17): [True: 0, False: 107] | Branch (1354:33): [True: 0, False: 0] | Branch (1354:51): [True: 0, False: 0] ------------------ 1355| 0| PAD(min_width, s_len, pad_char); ------------------ | | 294| 0|#define PAD(width, len, ch) \ | | 295| 0|do \ | | 296| 0|{ \ | | 297| 0| INS_CHAR(ch, sp, bep, cc); \ | | ------------------ | | | | 244| 0|#define INS_CHAR(c, sp, bep, cc) \ | | | | 245| 0|{ \ | | | | 246| 0| if (sp) { \ | | | | ------------------ | | | | | Branch (246:9): [True: 0, False: 0] | | | | ------------------ | | | | 247| 0| if (sp >= bep) { \ | | | | ------------------ | | | | | Branch (247:13): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| vbuff->curpos = sp; \ | | | | 249| 0| if (flush_func(vbuff)) \ | | | | ------------------ | | | | | Branch (249:17): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| return -1; \ | | | | 251| 0| sp = vbuff->curpos; \ | | | | 252| 0| bep = vbuff->endpos; \ | | | | 253| 0| } \ | | | | 254| 0| *sp++ = (c); \ | | | | 255| 0| } \ | | | | 256| 0| cc++; \ | | | | 257| 0|} | | ------------------ | | 298| 0| width--; \ | | 299| 0|} \ | | 300| 0|while (width > len) | | ------------------ | | | Branch (300:8): [True: 0, False: 0] | | ------------------ ------------------ 1356| 107| } 1357| 1.42k| fmt++; 1358| 1.42k| } 1359| 75| vbuff->curpos = sp; 1360| | 1361| 75| return cc; 1362| 75|} apr_snprintf.c:conv_p2: 617| 37|{ 618| 37| register int mask = (1 << nbits) - 1; 619| 37| register char *p = buf_end; 620| 37| static const char low_digits[] = "0123456789abcdef"; 621| 37| static const char upper_digits[] = "0123456789ABCDEF"; 622| 37| register const char *digits = (format == 'X') ? upper_digits : low_digits; ------------------ | Branch (622:35): [True: 37, False: 0] ------------------ 623| | 624| 49| do { 625| 49| *--p = digits[num & mask]; 626| 49| num >>= nbits; 627| 49| } 628| 49| while (num); ------------------ | Branch (628:12): [True: 12, False: 37] ------------------ 629| | 630| 37| *len = buf_end - p; 631| 37| return (p); 632| 37|} apr_pstrdup: 70| 45.8k|{ 71| 45.8k| char *res; 72| 45.8k| apr_size_t len; 73| | 74| 45.8k| if (s == NULL) { ------------------ | Branch (74:9): [True: 0, False: 45.8k] ------------------ 75| 0| return NULL; 76| 0| } 77| 45.8k| len = strlen(s) + 1; 78| 45.8k| res = apr_pmemdup(a, s, len); 79| 45.8k| return res; 80| 45.8k|} apr_pmemdup: 113| 56.9k|{ 114| 56.9k| void *res; 115| | 116| 56.9k| if (m == NULL) ------------------ | Branch (116:9): [True: 0, False: 56.9k] ------------------ 117| 0| return NULL; 118| 56.9k| res = apr_palloc(a, n); ------------------ | | 425| 56.9k| apr_palloc_debug(p, size, APR_POOL__FILE_LINE__) | | ------------------ | | | | 143| 56.9k|#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 160| 56.9k|#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 162| 56.9k|#define APR_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 119| 56.9k| memcpy(res, m, n); 120| 56.9k| return res; 121| 56.9k|} apr_os_thread_current: 340| 3.03k|{ 341| 3.03k| return pthread_self(); 342| 3.03k|}