util_expr_private.h

Go to the documentation of this file.

/* 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.
 */
 
#ifndef __AP_EXPR_PRIVATE_H__
#define __AP_EXPR_PRIVATE_H__
 
#include "httpd.h"
#include "apr_strings.h"
#include "apr_tables.h"
#include "ap_expr.h"
 
#ifndef YY_NULL
#define YY_NULL 0
#endif
 
#ifndef MIN
#define MIN(a,b) (((a)<(b))?(a):(b))
#endif
 
#if !APR_HAVE_UNISTD_H
#define YY_NO_UNISTD_H
#endif
 
#ifdef _MSC_VER
/* Avoid some warnings with Visual Studio (likely due to a bug in bison) */
#define YYMALLOC malloc
#define YYFREE   free
#endif
 
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
 
typedef enum {
    op_NOP,
    op_True, op_False,
    op_Not, op_Or, op_And,
    op_Comp,
    op_EQ, op_NE, op_LT, op_LE, op_GT, op_GE, op_IN,
    op_REG, op_NRE,
    op_STR_EQ, op_STR_NE, op_STR_LT, op_STR_LE, op_STR_GT, op_STR_GE,
    op_Concat,
    op_String, op_Word,
    op_Digit, op_Var, op_Bool, op_ListElement,
    op_Sub, op_Split, op_Join,
    op_Regex, op_Backref,
    /*
     * call external functions/operators.
     * The info node contains the function pointer and some function specific
     * info.
     * For Binary operators, the Call node links to the Info node and the
     * Args node, which in turn links to the left and right operand.
     * For all other variants, the Call node links to the Info node and the
     * argument.
     */
    op_UnaryOpCall, op_UnaryOpInfo,
    op_BinaryOpCall, op_BinaryOpInfo, op_BinaryOpArgs,
    op_StringFuncCall, op_StringFuncInfo,
    op_ListFuncCall, op_ListFuncInfo
} ap_expr_node_op_e;
 
struct ap_expr_node {
    ap_expr_node_op_e node_op;
    const void *node_arg1;
    const void *node_arg2;
};
 
typedef struct ap_expr_parser_stack {
    char *scan_ptr;
    char  scan_buf[MAX_STRING_LEN];
    int   scan_stop;
    int   scan_flag;
    struct ap_expr_parser_stack *next;
} ap_expr_parser_stack_t;
 
typedef struct {
    /* internal state of the scanner */
    const char        *inputbuf;
    int                inputlen;
    const char        *inputptr;
    void              *scanner;
    ap_expr_parser_stack_t *current,
                           *spares;
    int                at_start;
 
    /* pools for result and temporary usage */
    apr_pool_t        *pool;
    apr_pool_t        *ptemp;
 
    /* The created parse tree */
    ap_expr_t         *expr;
 
    const char        *error;
    const char        *error2;
    unsigned           flags;
 
    /*
     * The function to use to lookup provider functions for variables
     * and funtctions
     */
    ap_expr_lookup_fn_t *lookup_fn;
} ap_expr_parse_ctx_t;
 
/* flex/bison functions */
int  ap_expr_yyparse(ap_expr_parse_ctx_t *context);
void ap_expr_yyerror(ap_expr_parse_ctx_t *context, const char *err);
int  ap_expr_yylex_init(void **scanner);
int  ap_expr_yylex_destroy(void *scanner);
void ap_expr_yyset_extra(ap_expr_parse_ctx_t *context, void *scanner);
 
/* create a parse tree node */
ap_expr_t *ap_expr_make(ap_expr_node_op_e op, const void *arg1,
                        const void *arg2, ap_expr_parse_ctx_t *ctx);
ap_expr_t *ap_expr_concat_make(const void *a1, const void *a2,
                               ap_expr_parse_ctx_t *ctx);
ap_expr_t *ap_expr_regex_make(const char *pattern, const ap_expr_t *subst,
                              const char *flags, ap_expr_parse_ctx_t *ctx);
/* create parse tree node for the string-returning function 'name' */
ap_expr_t *ap_expr_str_func_make(const char *name, const ap_expr_t *arg,
                               ap_expr_parse_ctx_t *ctx);
/* create parse tree node for the list-returning function 'name' */
ap_expr_t *ap_expr_list_func_make(const char *name, const ap_expr_t *arg,
                                ap_expr_parse_ctx_t *ctx);
/* create parse tree node for the variable 'name' */
ap_expr_t *ap_expr_var_make(const char *name, ap_expr_parse_ctx_t *ctx);
/* create parse tree node for the back reference 'num' */
ap_expr_t *ap_expr_backref_make(int num, ap_expr_parse_ctx_t *ctx);
/* create parse tree node for the unary operator 'name' */
ap_expr_t *ap_expr_unary_op_make(const char *name, const ap_expr_t *arg,
                               ap_expr_parse_ctx_t *ctx);
/* create parse tree node for the binary operator 'name' */
ap_expr_t *ap_expr_binary_op_make(const char *name, const ap_expr_t *arg1,
                                  const ap_expr_t *arg2,
                                  ap_expr_parse_ctx_t *ctx);
 
 
#endif /* __AP_EXPR_PRIVATE_H__ */