| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* based on ap_expr_parse.y from mod_ssl */ |
| |
| /* _________________________________________________________________ |
| ** |
| ** Expression Parser |
| ** _________________________________________________________________ |
| */ |
| |
| %pure-parser |
| %error-verbose |
| %defines |
| %lex-param { void *yyscanner } |
| %parse-param { ap_expr_parse_ctx_t *ctx } |
| |
| %{ |
| #include "util_expr_private.h" |
| %} |
| |
| %union { |
| char *cpVal; |
| ap_expr_t *exVal; |
| int num; |
| } |
| |
| %token T_TRUE "true" |
| %token T_FALSE "false" |
| |
| %token T_EXPR_BOOL "boolean expression" |
| %token T_EXPR_STRING "string expression" |
| |
| %token <cpVal> T_ERROR "error token" |
| |
| %token <cpVal> T_DIGIT "number" |
| %token <cpVal> T_ID "identifier" |
| %token <cpVal> T_STRING "string literal" |
| |
| %token T_REGEX "start of matching regex" |
| %token T_REGSUB "start of substitution regex" |
| %token <cpVal> T_REG_MATCH "pattern of the regex" |
| %token <cpVal> T_REG_SUBST "substitution of the regex" |
| %token <cpVal> T_REG_FLAGS "pattern flags of the regex" |
| %token <num> T_BACKREF "regex back reference" |
| |
| %token <cpVal> T_OP_UNARY "unary operator" |
| %token <cpVal> T_OP_BINARY "binary operator" |
| |
| %token T_STR_BEGIN "start of string" |
| %token T_STR_END "end of string" |
| %token T_VAR_BEGIN "start of variable name" |
| %token T_VAR_END "end of variable name" |
| %token T_VAREXP_BEGIN "start of variable expression" |
| %token T_VAREXP_END "end of variable expression" |
| |
| %token T_OP_EQ "integer equal" |
| %token T_OP_NE "integer not equal" |
| %token T_OP_LT "integer less than" |
| %token T_OP_LE "integer less or equal" |
| %token T_OP_GT "integer greater than" |
| %token T_OP_GE "integer greater or equal" |
| %token T_OP_REG "regex match" |
| %token T_OP_NRE "regex non-match" |
| %token T_OP_IN "contained in" |
| %token T_OP_STR_EQ "string equal" |
| %token T_OP_STR_NE "string not equal" |
| %token T_OP_STR_LT "string less than" |
| %token T_OP_STR_LE "string less or equal" |
| %token T_OP_STR_GT "string greater than" |
| %token T_OP_STR_GE "string greater or equal" |
| |
| %token T_OP_CONCAT "string concatenation" |
| |
| %token T_OP_JOIN "join operator" |
| %token T_OP_SPLIT "split operator" |
| %token T_OP_SUB "substitute operator" |
| |
| %token T_OP_OR "logical or" |
| %token T_OP_AND "logical and" |
| %token T_OP_NOT "logical not" |
| |
| %left T_OP_OR |
| %left T_OP_AND |
| %right T_OP_NOT |
| %right T_OP_CONCAT |
| |
| %nterm <exVal> cond |
| %nterm <exVal> comp |
| %nterm <exVal> strfunc |
| %nterm <exVal> listfunc |
| %nterm <exVal> list |
| %nterm <exVal> words |
| %nterm <exVal> word |
| %nterm <exVal> string |
| %nterm <exVal> substr |
| %nterm <exVal> var |
| %nterm <exVal> regex |
| %nterm <exVal> regsub |
| %nterm <exVal> regany |
| %nterm <exVal> split |
| %nterm <exVal> join |
| %nterm <exVal> sub |
| |
| %{ |
| #include "util_expr_private.h" |
| #define yyscanner ctx->scanner |
| |
| int ap_expr_yylex(YYSTYPE *lvalp, void *scanner); |
| %} |
| |
| |
| %% |
| |
| expr : T_EXPR_STRING string { ctx->expr = $2; } |
| | T_EXPR_BOOL cond { ctx->expr = $2; } |
| | T_ERROR { YYABORT; } |
| ; |
| |
| string : substr { $$ = $1; } |
| | string substr { $$ = ap_expr_concat_make($1, $2, ctx); } |
| | T_ERROR { YYABORT; } |
| ; |
| |
| cond : T_TRUE { $$ = ap_expr_make(op_True, NULL, NULL, ctx); } |
| | T_FALSE { $$ = ap_expr_make(op_False, NULL, NULL, ctx); } |
| | T_OP_NOT cond { $$ = ap_expr_make(op_Not, $2, NULL, ctx); } |
| | cond T_OP_OR cond { $$ = ap_expr_make(op_Or, $1, $3, ctx); } |
| | cond T_OP_AND cond { $$ = ap_expr_make(op_And, $1, $3, ctx); } |
| | comp { $$ = ap_expr_make(op_Comp, $1, NULL, ctx); } |
| | T_OP_UNARY word { $$ = ap_expr_unary_op_make( $1, $2, ctx); } |
| | word T_OP_BINARY word { $$ = ap_expr_binary_op_make($2, $1, $3, ctx); } |
| | '(' cond ')' { $$ = $2; } |
| | T_ERROR { YYABORT; } |
| ; |
| |
| comp : word T_OP_EQ word { $$ = ap_expr_make(op_EQ, $1, $3, ctx); } |
| | word T_OP_NE word { $$ = ap_expr_make(op_NE, $1, $3, ctx); } |
| | word T_OP_LT word { $$ = ap_expr_make(op_LT, $1, $3, ctx); } |
| | word T_OP_LE word { $$ = ap_expr_make(op_LE, $1, $3, ctx); } |
| | word T_OP_GT word { $$ = ap_expr_make(op_GT, $1, $3, ctx); } |
| | word T_OP_GE word { $$ = ap_expr_make(op_GE, $1, $3, ctx); } |
| | word T_OP_STR_EQ word { $$ = ap_expr_make(op_STR_EQ, $1, $3, ctx); } |
| | word T_OP_STR_NE word { $$ = ap_expr_make(op_STR_NE, $1, $3, ctx); } |
| | word T_OP_STR_LT word { $$ = ap_expr_make(op_STR_LT, $1, $3, ctx); } |
| | word T_OP_STR_LE word { $$ = ap_expr_make(op_STR_LE, $1, $3, ctx); } |
| | word T_OP_STR_GT word { $$ = ap_expr_make(op_STR_GT, $1, $3, ctx); } |
| | word T_OP_STR_GE word { $$ = ap_expr_make(op_STR_GE, $1, $3, ctx); } |
| | word T_OP_REG regex { $$ = ap_expr_make(op_REG, $1, $3, ctx); } |
| | word T_OP_NRE regex { $$ = ap_expr_make(op_NRE, $1, $3, ctx); } |
| | word T_OP_IN list { $$ = ap_expr_make(op_IN, $1, $3, ctx); } |
| ; |
| |
| word : T_DIGIT { $$ = ap_expr_make(op_Digit, $1, NULL, ctx); } |
| | T_STR_BEGIN T_STR_END { $$ = ap_expr_make(op_String, "", NULL, ctx); } |
| | T_STR_BEGIN string T_STR_END { $$ = $2; } |
| | word T_OP_CONCAT word { $$ = ap_expr_make(op_Concat, $1, $3, ctx); } |
| | var { $$ = $1; } |
| | sub { $$ = $1; } |
| | join { $$ = $1; } |
| | strfunc { $$ = $1; } |
| | '(' word ')' { $$ = $2; } |
| ; |
| |
| list : split { $$ = $1; } |
| | listfunc { $$ = $1; } |
| | '{' words '}' { $$ = $2; } |
| | '(' list ')' { $$ = $2; } |
| ; |
| |
| substr : T_STRING { $$ = ap_expr_make(op_String, $1, NULL, ctx); } |
| | var { $$ = $1; } |
| ; |
| |
| var : T_VAR_BEGIN T_ID T_VAR_END { $$ = ap_expr_var_make($2, ctx); } |
| | T_VAR_BEGIN T_ID ':' string T_VAR_END { $$ = ap_expr_str_func_make($2, $4, ctx); } |
| | T_VAREXP_BEGIN cond T_VAREXP_END { $$ = ap_expr_make(op_Bool, $2, NULL, ctx); } |
| | T_VAREXP_BEGIN word T_VAREXP_END { $$ = ap_expr_make(op_Word, $2, NULL, ctx); } |
| | T_BACKREF { $$ = ap_expr_backref_make($1, ctx); } |
| ; |
| |
| strfunc : T_ID '(' word ')' { $$ = ap_expr_str_func_make($1, $3, ctx); } |
| | T_ID '(' words ')' { $$ = ap_expr_str_func_make($1, $3, ctx); } |
| ; |
| |
| listfunc : T_ID '(' word ')' { $$ = ap_expr_list_func_make($1, $3, ctx); } |
| /* | T_ID '(' words ')' { $$ = ap_expr_list_func_make($1, $3, ctx); } */ |
| ; |
| |
| sub : T_OP_SUB regsub ',' word { $$ = ap_expr_make(op_Sub, $4, $2, ctx); } |
| | T_OP_SUB '(' regsub ',' word ')' { $$ = ap_expr_make(op_Sub, $5, $3, ctx); } |
| ; |
| |
| join : T_OP_JOIN list { $$ = ap_expr_make(op_Join, $2, NULL, ctx); } |
| | T_OP_JOIN '(' list ')' { $$ = ap_expr_make(op_Join, $3, NULL, ctx); } |
| | T_OP_JOIN list ',' word { $$ = ap_expr_make(op_Join, $2, $4, ctx); } |
| | T_OP_JOIN '(' list ',' word ')' { $$ = ap_expr_make(op_Join, $3, $5, ctx); } |
| ; |
| |
| split : T_OP_SPLIT regany ',' list { $$ = ap_expr_make(op_Split, $4, $2, ctx); } |
| | T_OP_SPLIT '(' regany ',' list ')' { $$ = ap_expr_make(op_Split, $5, $3, ctx); } |
| | T_OP_SPLIT regany ',' word { $$ = ap_expr_make(op_Split, $4, $2, ctx); } |
| | T_OP_SPLIT '(' regany ',' word ')' { $$ = ap_expr_make(op_Split, $5, $3, ctx); } |
| ; |
| |
| words : word { $$ = ap_expr_make(op_ListElement, $1, NULL, ctx); } |
| | word ',' words { $$ = ap_expr_make(op_ListElement, $1, $3, ctx); } |
| ; |
| |
| regex : T_REGEX T_REG_MATCH T_REG_FLAGS { |
| ap_expr_t *e = ap_expr_regex_make($2, NULL, $3, ctx); |
| if (!e) { |
| ctx->error = "Failed to compile regular expression"; |
| YYERROR; |
| } |
| $$ = e; |
| } |
| ; |
| regsub : T_REGSUB T_REG_MATCH string T_REG_FLAGS { |
| ap_expr_t *e = ap_expr_regex_make($2, $3, $4, ctx); |
| if (!e) { |
| ctx->error = "Failed to compile regular expression"; |
| YYERROR; |
| } |
| $$ = e; |
| } |
| ; |
| regany : regex { $$ = $1; } |
| | regsub { $$ = $1; } |
| ; |
| |
| %% |
| |
| void yyerror(ap_expr_parse_ctx_t *ctx, const char *s) |
| { |
| /* s is allocated on the stack */ |
| ctx->error = apr_pstrdup(ctx->ptemp, s); |
| } |
| |
