La Forme de Backus-Naur (souvent abrégée en BNF, de l'anglais Backus-Naur Form) est une notation permettant de décrire les règles syntaxiques des langages de programmation. En général, les expressions représentent des valeurs booléennes. Dans ce cas, le point de départ de la BNF est cond. Les directives comme ErrorDocument, Require, AuthName, Redirect, Header, CryptoKey ou LogMessage utilisent comme paramètres des expressions qui représentent des chaînes de caractères. Dans ce cas, le point de départ de la BNF est string.

expr        ::= cond
              | string

string      ::= substring
              | string substring

cond        ::= "true" 
              | "false"
              | "!" cond
              | cond "&&" cond
              | cond "||" cond
              | comp
	      | "(" cond ")"

comp        ::= stringcomp
              | integercomp
              | unaryop word
              | word binaryop word
              | word "in" listfunc
              | word "=~" regex
              | word "!~" regex
	      | word "in" "{" list "}"


stringcomp  ::= word "==" word
              | word "!=" word
              | word "<"  word
              | word "<=" word
              | word ">"  word
              | word ">=" word

integercomp ::= word "-eq" word | word "eq" word
              | word "-ne" word | word "ne" word
              | word "-lt" word | word "lt" word
              | word "-le" word | word "le" word
              | word "-gt" word | word "gt" word
              | word "-ge" word | word "ge" word

word        ::= digits
              | "'" string "'"
              | '"' string '"'
              | word "." word
              | variable
	      | sub
              | join
              | function
	      | "(" word ")"

list        ::= split
              | listfunc
              | "{" words "}"
              | "(" list ")"

substring   ::= cstring
              | variable


variable    ::= "%{" varname "}"
              | "%{" funcname ":" funcargs "}"
	      | "%{:" word ":}"
              | "%{:" cond ":}"
              | rebackref

sub         ::= "sub" ["("] regsub "," word [")"]

join        ::= "join" ["("] list [")"]
              | "join" ["("] list "," word [")"]

split       ::= "split" ["("] regany "," list [")"]
              | "split" ["("] regany "," word [")"]

function    ::= funcname "(" words ")"

listfunc    ::= listfuncname "(" words ")"

words       ::= word
              | word "," list

regex       ::= "/" regpattern "/" [regflags]
              | "m" regsep regpattern regsep [regflags]

regsub      ::= "s" regsep regpattern regsep string regsep [regflags]

regany      ::= regex | regsub

regsep      ::= "/" | "#" | "$" | "%" | "^" | "|" | "?" | "!" | "'" | '"' | "," | ";" | ":" | "." | "_" | "-"

regflags    ::= 1*("i" | "s" | "m" | "g")
regpattern  ::= cstring ; except enclosing regsep

rebackref   ::= "$" DIGIT

digits      ::= 1*(DIGIT)
cstring     ::= 0*(TEXT)

TEXT        ::= <any OCTET except CTLs>
DIGIT       ::= <any US-ASCII digit "0".."9">

L'interpréteur d'expressions fournit plusieurs variables de la forme %{HTTP_HOST}. Notez que la valeur d'une variable peut dépendre de la phase du traitement de la requête au cours de laquelle elle est évaluée. Par exemple, une expression utilisée dans une directive <If > sera évaluée avant la phase d'authentification. Par conséquent, la variable %{REMOTE_USER} ne sera pas encore définie à ce stade.

Les variables suivantes contiennent la valeur de l'en-tête de requête HTTP correspondant. La fonction req permet d'extraire les valeurs des autres en-têtes. L'utilisation de ces variables peut provoquer l'ajout du nom d'en-tête correspondant à l'en-tête Vary de la réponse HTTP, sauf spécification contraire pour la directive qui accepte l'expression comme paramètre. La function req_novary permet de modifier ce comportement.

Autres variables liées aux requêtes

Variables diverses

Certains modules, comme mod_ssl, définissent des variables supplémentaires.

Toute variable peut être insérée dans une chaîne, et ceci non seulement dans les chaînes entre quotes des expressions booléennes, mais aussi dans les expressions littérales issues de la concaténation de chaînes constantes et dynamiques.

On peut utiliser ici les variables (temporaires) du style %{:word:} qui permettent d'insérer dans les deux types d'expressions des variables (et des constructions) avec la syntaxe puissante word sans entrer en conflit avec les parties constantes de telles chaînes. Même si la syntaxe word est directement utilisable au sein des expressions booléennes, ces variables sont cependant surtout utiles dans les expressions littérales. Ces variables permettent d'évaluer des expressions rationnelles, des substitutions, de concaténer ou dissocier des chaînes et des listes au sein des expressions littérales, et donc de construire des chaînes complexes dynamiquement.

À l'exception de quelques opérateurs de comparaison internes, les opérateurs binaires sont de la forme "-[a-zA-Z][a-zA-Z0-9_]+", autrement dit un signe moins et au moins deux caractères. Le nom est insensible à la casse. Les modules peuvent fournir des opérateurs binaires supplémentaires.

Les opérateurs unaires acceptent un seul argument et sont de la forme "-[a-zA-Z]", autrement dit le signe moins et un caractère. Le nom est sensible à la casse. Les modules peuvent fournir des opérateurs unaires supplémentaires.

Les opérateurs marqués comme "restreints" ne sont pas disponibles avec certains modules comme mod_include.

Normalement, les fonctions dont la valeur est une chaîne acceptent une chaîne comme argument et renvoient une chaîne. Les noms de fonctions sont insensibles à la casse. Les modules peuvent fournir des fonctions supplémentaires.

Les fonctions marquées comme "limité" dans la dernière colonne ne sont pas disponibles avec certains modules comme mod_include.

Les fonctions marquées comme "ordonnancement" dans la dernière colonne nécessitent une attention particulière pour l'ordonnancement des différents composants du serveur, spécialement lorsque la fonction est utilisée au sein d'une directive <If> qui est évaluée relativement tôt.

Lorsque les fonctions req ou http sont utilisées, le nom d'en-tête sera automatiquement ajouté à l'en-tête Vary de la réponse HTTP, sauf spécification contraire pour la directive qui accepte l'expression comme paramètre. La fonction req_novary permet d'empêcher cet ajout.

En plus des fonctions dont la valeur est une chaîne, il existe aussi des fonctions dont la valeur est une liste, qui acceptent une chaîne comme argument, et renvoient une liste , par exemple une liste de chaînes. La liste peut être utilisée avec l'opérateur spécial -in. Les noms de fonctions sont insensibles à la casse. Les modules peuvent fournir des fonctions supplémentaires.

Il n'existe pas de fonctions internes dont la valeur est une liste. Le module mod_ssl fournit la fonction PeerExtList. Voir la description de la directive SSLRequire pour plus de détails (notez que la fonction PeerExtList peut aussi être utilisée en dehors de la directive SSLRequire).

La syntaxe ap_expr consiste principalement en une surcouche de la syntaxe de la directive obsolète SSLRequire. Vous pouvez consulter la liste de leur différences dans la documentation de la directive SSLRequire.

La fonction req_novary est disponible à partir de la version 2.4.4 du serveur HTTP Apache.

Les variables SERVER_PROTOCOL_VERSION, SERVER_PROTOCOL_VERSION_MAJOR et SERVER_PROTOCOL_VERSION_MINOR sont disponibles à partir de la version 2.5.0 du serveur HTTP Apache.

Les exemples suivants montent comment utiliser les expressions pour évaluer les requêtes :