Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
tree: ff431411f6
Fetching contributors…

Cannot retrieve contributors at this time

401 lines (357 sloc) 9.18 kb
/* 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.
*/
/*
* ap_expr_scan.l, based on ssl_expr_scan.l from mod_ssl
*/
/* _________________________________________________________________
**
** Expression Scanner
** _________________________________________________________________
*/
%pointer
%option batch
%option never-interactive
%option nodefault
%option noyywrap
%option reentrant
%option bison-bridge
%option warn
%option noinput nounput noyy_top_state
%option stack
%x str
%x var
%x vararg
%x regex regex_flags
%{
#include "util_expr_private.h"
#include "util_expr_parse.h"
#undef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
{ \
if ((result = MIN(max_size, yyextra->inputbuf \
+ yyextra->inputlen \
- yyextra->inputptr)) <= 0) \
{ \
result = YY_NULL; \
} \
else { \
memcpy(buf, yyextra->inputptr, result); \
yyextra->inputptr += result; \
} \
}
#define YY_EXTRA_TYPE ap_expr_parse_ctx_t*
#define PERROR(msg) do { yyextra->error2 = msg ; return T_ERROR; } while (0)
#define str_ptr (yyextra->scan_ptr)
#define str_buf (yyextra->scan_buf)
#define str_del (yyextra->scan_del)
#define STR_APPEND(c) do { \
*str_ptr++ = (c); \
if (str_ptr >= str_buf + sizeof(str_buf)) \
PERROR("String too long"); \
} while (0)
%}
%%
char regex_buf[MAX_STRING_LEN];
char *regex_ptr = NULL;
char regex_del = '\0';
%{
/*
* Set initial state for string expressions
*/
if (yyextra->at_start) {
yyextra->at_start = 0;
if (yyextra->flags & AP_EXPR_FLAG_STRING_RESULT) {
BEGIN(str);
return T_EXPR_STRING;
}
else {
return T_EXPR_BOOL;
}
}
%}
/*
* Whitespaces
*/
[ \t\n]+ {
/* NOP */
}
/*
* strings ("..." and '...')
*/
["'] {
str_ptr = str_buf;
str_del = yytext[0];
BEGIN(str);
return T_STR_BEGIN;
}
<str>["'] {
if (yytext[0] == str_del) {
if (YY_START == var) {
PERROR("Unterminated variable in string");
}
else if (str_ptr == str_buf) {
BEGIN(INITIAL);
return T_STR_END;
}
else {
/* return what we have so far and scan delimiter again */
*str_ptr = '\0';
yylval->cpVal = apr_pstrdup(yyextra->pool, str_buf);
yyless(0);
str_ptr = str_buf;
return T_STRING;
}
}
else {
STR_APPEND(yytext[0]);
}
}
<str,var,vararg>\n {
PERROR("Unterminated string or variable");
}
<var,vararg><<EOF>> {
PERROR("Unterminated string or variable");
}
<str><<EOF>> {
if (!(yyextra->flags & AP_EXPR_FLAG_STRING_RESULT)) {
PERROR("Unterminated string or variable");
}
else {
*str_ptr = '\0';
yylval->cpVal = apr_pstrdup(yyextra->pool, str_buf);
str_ptr = str_buf;
BEGIN(INITIAL);
return T_STRING;
}
}
<str,vararg>\\[0-7]{1,3} {
int result;
(void)sscanf(yytext+1, "%o", &result);
if (result > 0xff) {
PERROR("Escape sequence out of bound");
}
else {
STR_APPEND(result);
}
}
<str,vararg>\\[0-9]+ {
PERROR("Bad escape sequence");
}
<str,vararg>\\n { STR_APPEND('\n'); }
<str,vararg>\\r { STR_APPEND('\r'); }
<str,vararg>\\t { STR_APPEND('\t'); }
<str,vararg>\\b { STR_APPEND('\b'); }
<str,vararg>\\f { STR_APPEND('\f'); }
<str,vararg>\\(.|\n) { STR_APPEND(yytext[1]); }
/* regexp backref inside string/arg */
<str,vararg>[$][0-9] {
if (str_ptr != str_buf) {
/* return what we have so far and scan '$x' again */
*str_ptr = '\0';
yylval->cpVal = apr_pstrdup(yyextra->pool, str_buf);
str_ptr = str_buf;
yyless(0);
return T_STRING;
}
else {
yylval->num = yytext[1] - '0';
return T_REGEX_BACKREF;
}
}
<str,vararg>[^\\\n"'%}$]+ {
char *cp = yytext;
while (*cp != '\0') {
STR_APPEND(*cp);
cp++;
}
}
/* variable inside string/arg */
<str,vararg>%\{ {
if (str_ptr != str_buf) {
/* return what we have so far and scan '%{' again */
*str_ptr = '\0';
yylval->cpVal = apr_pstrdup(yyextra->pool, str_buf);
yyless(0);
str_ptr = str_buf;
return T_STRING;
}
else {
yy_push_state(var, yyscanner);
return T_VAR_BEGIN;
}
}
<vararg>[%$] {
STR_APPEND(yytext[0]);
}
<str>[%}$] {
STR_APPEND(yytext[0]);
}
%\{ {
yy_push_state(var, yyscanner);
return T_VAR_BEGIN;
}
[$][0-9] {
yylval->num = yytext[1] - '0';
return T_REGEX_BACKREF;
}
/*
* fixed name variable expansion %{XXX} and function call in %{func:arg} syntax
*/
<var>[a-zA-Z][a-zA-Z0-9_]* {
yylval->cpVal = apr_pstrdup(yyextra->pool, yytext);
return T_ID;
}
<var>\} {
yy_pop_state(yyscanner);
return T_VAR_END;
}
<var>: {
BEGIN(vararg);
return yytext[0];
}
<var>.|\n {
char *msg = apr_psprintf(yyextra->pool,
"Invalid character in variable name '%c'", yytext[0]);
PERROR(msg);
}
<vararg>\} {
if (str_ptr != str_buf) {
/* return what we have so far and scan '}' again */
*str_ptr = '\0';
yylval->cpVal = apr_pstrdup(yyextra->pool, str_buf);
str_ptr = str_buf;
yyless(0);
return T_STRING;
}
else {
yy_pop_state(yyscanner);
return T_VAR_END;
}
}
/*
* Regular Expression
*/
"m"[/#$%^,;:_\?\|\^\-\!\.\'\"] {
regex_del = yytext[1];
regex_ptr = regex_buf;
BEGIN(regex);
}
"/" {
regex_del = yytext[0];
regex_ptr = regex_buf;
BEGIN(regex);
}
<regex>.|\n {
if (yytext[0] == regex_del) {
*regex_ptr = '\0';
BEGIN(regex_flags);
}
else {
*regex_ptr++ = yytext[0];
if (regex_ptr >= regex_buf + sizeof(regex_buf))
PERROR("Regexp too long");
}
}
<regex_flags>i {
yylval->cpVal = apr_pstrdup(yyextra->pool, regex_buf);
BEGIN(INITIAL);
return T_REGEX_I;
}
<regex_flags>.|\n {
yylval->cpVal = apr_pstrdup(yyextra->pool, regex_buf);
yyless(0);
BEGIN(INITIAL);
return T_REGEX;
}
<regex_flags><<EOF>> {
yylval->cpVal = apr_pstrdup(yyextra->pool, regex_buf);
BEGIN(INITIAL);
return T_REGEX;
}
/*
* Operators
*/
==? { return T_OP_STR_EQ; }
"!=" { return T_OP_STR_NE; }
"<" { return T_OP_STR_LT; }
"<=" { return T_OP_STR_LE; }
">" { return T_OP_STR_GT; }
">=" { return T_OP_STR_GE; }
"=~" { return T_OP_REG; }
"!~" { return T_OP_NRE; }
"and" { return T_OP_AND; }
"&&" { return T_OP_AND; }
"or" { return T_OP_OR; }
"||" { return T_OP_OR; }
"not" { return T_OP_NOT; }
"!" { return T_OP_NOT; }
"." { return T_OP_CONCAT; }
"-in" { return T_OP_IN; }
"-eq" { return T_OP_EQ; }
"-ne" { return T_OP_NE; }
"-ge" { return T_OP_GE; }
"-le" { return T_OP_LE; }
"-gt" { return T_OP_GT; }
"-lt" { return T_OP_LT; }
/* for compatibility with ssl_expr */
"lt" { return T_OP_LT; }
"le" { return T_OP_LE; }
"gt" { return T_OP_GT; }
"ge" { return T_OP_GE; }
"ne" { return T_OP_NE; }
"eq" { return T_OP_EQ; }
"in" { return T_OP_IN; }
"-"[a-zA-Z_] {
yylval->cpVal = apr_pstrdup(yyextra->pool, yytext + 1);
return T_OP_UNARY;
}
"-"[a-zA-Z_][a-zA-Z_0-9]+ {
yylval->cpVal = apr_pstrdup(yyextra->pool, yytext + 1);
return T_OP_BINARY;
}
/*
* Specials
*/
"true" { return T_TRUE; }
"false" { return T_FALSE; }
/*
* Digits
*/
-?[0-9]+ {
yylval->cpVal = apr_pstrdup(yyextra->pool, yytext);
return T_DIGIT;
}
/*
* Identifiers
*/
[a-zA-Z][a-zA-Z0-9_]* {
yylval->cpVal = apr_pstrdup(yyextra->pool, yytext);
return T_ID;
}
/*
* These are parts of the grammar and are returned as is
*/
[(){},:] {
return yytext[0];
}
/*
* Anything else is an error
*/
.|\n {
char *msg = apr_psprintf(yyextra->pool, "Parse error near '%c'", yytext[0]);
PERROR(msg);
}
%%
Jump to Line
Something went wrong with that request. Please try again.