Update inline docs for builtin xlats

Don't delete .work file if there are outstanding requests

just use %l or %c directly

there's no need to convert them to dates, and then cast them to
integers.  Those expansions are already integers

typo

stop on empty buffer, too.

The fr_pair_list_afrom_str() function should really be converted
to sbuffs, but that isn't immediately trivial.

It expect to see NUL-terminated C strings, and will misbehave
if given bad data.  Happily, all of the stgring value-boxes in
the server are zero-terminated, so this isn't much of an issue.

The same goes for input from unit_test_attribute.

add assertion for paranoia

docs corrections

add end check to loop limit

and remove end check inside of loop.

The fr_struct_from_network() function will also enforce "end"

document "retransmit=no"

retry.count is incremented by fr_retry_next()

if we're not retransmitting, mark done even on failure

note limitations

Debug output correction

list overrides are not allowed

The edit.c code calls fr_pair_list_afrom_str(), which does NOT
handle list over-rides.

Plus, we are assigning to a list as

&list += "pairs = value"

so having a list override does not make sense.

better error messages, so that we know what's going on

just use the right comparison

empty lists are equal when compared via ==

add %test.fail() which always returns XLAT_ACTION_FAIL

make !(a == b) the same as (a != b)

clarify error

update antora config

don't always try and be clever with the package version

add dist version checks from v3

update version.sh to cope with a prerelease

fix version.sh output when we're on a tag

use commas in function args and other cleanups

allow &foo := {} to mean "delete leaf attributes"

because if the RHS is a dynamic expansion which returns no values,
that's what it means there

use the correct array offsets.

Perhaps these changes should stop

quiet static analyzer

if we didn't find any match, return false

read the debug output a bit more and fix the tests

move this back to before &&/|| changes

try to quiet clang scan

separate out && and || code, and clean up tests

move %(foo:) to new syntax

move to new syntax

perl -p -i -e 's/%\(([a-zA-Z0-0._-]+):([a-zA-Z0-9.]+)\)/%$1\($2\)/g'   $(git grep -lE '%\([a-z]+:' src/tests/keywords/)

perl -p -i -e 's/%\(([a-zA-Z0-0._-]+):%{([^%{}]+)}\)/%$1\(%{$2}\)/g'   $(git grep -lE '%\([a-z]+:' src/tests/keywords/)

conver to new function syntax

more remove alternation :-

catch corner cases of && and ||

where there's no input, so the output shouldn't exist, either

remove alternation

Align xlat function debug with new function call format

Update LDAP tests

Remove unnecessary ""

Revert "auto-convert LDAP"

This reverts commit b4af84428990140af855f5ca7a6ecbc7790cc4bf.

Nope.  LDAP tests fail.  Reverting until we do the conversion
manually.

auto-convert functions with fixed string arguments

perl -p -i -e "s/%{([a-zA-Z0-9._-]+):([^&%{}=']+)}/%\$1('\$2')/g"  $(git grep -lE '%\{[a-z0-9.-]+:' src/tests/keywords/ src/tests/modules)

auto-convert LDAP

perl -p -i -e 's/"%{ldap:(.*?)}"/%ldap("$1")/' $(git grep -lE '%\{[a-z]+:' src/tests/modules/)

auto-convert SQL

perl -p -i -e 's/"%{sql:(.*?)}"/%sql("$1")/' $(git grep -lE '%\{[a-z]+:' src/tests/modules/)

more auto-conversion

perl -p -i -e "s/%{([a-zA-Z0-9._-]+):([a-zA-Z0-9.]+)}/%\$1('\$2')/g"  $(git grep -lE '%\{[a-z0-9.-]+:' src/tests/keywords/ src/tests/modules)

auto-convert to new syntax

perl -p -i -e 's/%{([a-zA-Z0-9._-]+):%{([a-zA-Z0-9._-]+)}}/%$1(%{$2})/g'  $(git grep -lE '%\{[a-z]+:' src/tests/keywords/)

Coverity #1547098

add missing case

add log.debug() and log.info()

so that we can log to the normal request log in unlang

add "request" destination for linelog

so that it can log to the normal request log

remove old text

stupid local compiler misses things

remove %expr()

more typos

show which condition failed to parse

typo

update redis tests to not use %expr

quiet static analyzer

more "get rid of expr"

get rid of backticks in tests

don't pull casts into in-place expressions

because that would change how the text inside of the expression
is parsed, and we don't want that

don't allow unresolved functions at runtime

because otherwise xlat_resolve() will call xlat_bootstrap_func(),
which modifies the xlat_inst_tree at runtime, from a child thread

just move everything to xlat_bootstrap()

quiet static analyzer

add xlat wrapper function for bootstrap / instantiate ephemeral

* xlat_bootstrap() - when reading the configuration files
  pretty much only called by xlat_redundant()

* xlat_instantiate_ephemeral() - when we have a #request_t and
  are parsing things at run-time

* xlat_finalize() - when we have a #tmpl_rules_t, and we're not
  sure if we're run-time or config load time.

The issue is that the various xlat tokenize funtions call each
other in different combinations.  The only way to consistently
know if we're run-time or config time is via the #tmpl_rules_t.

This change (also via previous commits) allows us to get rid of
the various public tokenize_ephemeral() functions, which were
confusing the issue.

ensure runtime_el is set

and instantiate ephemeral xlats in tmpl_tokenize

move to xlat_tokenize(), as ephemeral checks are in t_rules

get rid of tokenize_ephemeral_expression()

and just rely on t_rules->xlat.runtime_el

make cmp return bool and fix associated tests

use t_rules->xlat.runtime_el

more set head->el

it's an expansion

notes on quoting

Delete from correct table

Alternation fixes

don't do too much optimization for logical or

NAK clients don't have a connection - report the src IP instead

Blank correct pairs in dynamic client requests

Run correct section when new client fails

Bad DN LDAP response is really notfound, not fail

push event list down to ephemeral expressions

remove extraneous empty line

don't use bare words in || expansions

more move to new function syntax

get rid of old function syntax everywhere except old examples

more remove alternation

this time where the second argument is just a string, and not
an attribute reference

perl -p -i -e 's/%{%{([^%{}]+)}:-([^%{}]+)}/%{\&$1 || $2}/g'  $(git grep -l ':-' raddb/)

and then re-build the antora docs from the raddb sources

remove much alternation

perl -p -i -e 's/%{%{([^%{}]+)}:-%{([^%{}]+)}}/%{\&$1 || \&$2}/g'  $(git grep -l ':-' raddb/)

and then re-build the antora docs from the raddb sources

typos

totp: The fr_totp_cmp() expects token in call_env 'user_password'

Which is taken from control.TOTP.From-User

totp: Fix call_env setting

The 'nullable' field should be true.

note that you don't always have to use %concat()

"+" is usually better.

add more tests

move to %func(args) everywhere in raddb/*

xlat cmp requires both arguments

handle multiple values better with list on the RHS

If we have :=, then create multiple values.

if we have other operators, then only create the first one,
and then apply the operations to it

don't create multiple copies of local variables

split out comparison from binary ops

there's no real reason for them to be the same

allow n-ary operations for time delta, too

add calc n-ary op, for add, or, and, xor, etc.

This should make expressions a bit more efficient, as there will
be fewer intermediate nodes, and more work will be done at parse
time.

The expr wrappers aren't done, so that needs adding.  We will have
to do some cleanups of the resolve, etc. code for that to be best.

The logical operators || and && aren't implemented in calc.c,
because they are short-circuit operators, and calc.c gets a fully
evaluated list of value-boxes.

That being said, it's likely not much work to add short-circuit
operators to the calc.c code.