Wording for “Function literals”

2′ Similarly, in the body of a function literal, __func__ is declared in the same way, only that here "function-name" is an implementation-defined non-empty multi-byte string literal that does not contain control characters; such string literals need not to be unique.

Constraints

2 A postfix expression starting

( storage-class-specifiers_opt type-name ) {

such that the type name refers to an object type shall be a compound literal; otherwise, it shall be a function literal.

6.5.3.7 Function literals

Syntax

1 function-literal:

( attribute-specifier-sequence_opt declaration-specifiers abstract-declarator ) function-body

Constraints

2 If a function literal (ASS DS AD) BODY is associated with file scope or block scope (see 6.2.1), SCFS are the storage-class and function specifiers in DS, possibly empty, SPL is the resulting specifier qualifier list where the storage-class and function specifiers are removed from DS, and ID is an identifier that is unique for the whole program, then

ASS SCFS typeof(SPL AD) ID;

shall be a valid function declaration in the same scope as the function literal. Furthermore, there shall be a declarator D such that

• the token ID occurs exactly once in the token sequence of D,
• removing the token ID from D results in the same token sequence as AD,

and such that

ASS DS D BODY

in the same scope as the function literal shall be a compatible function definition with name ID.

3 All the constraints for function definitions (6.9.2) also apply to function literals.

Semantics

4 Independently of the scope in which it appears, the type of a function literal is typeof(SPL AD) as given for the declaration syntax in the constraints. For a function literal associated with function prototype scope the type is determined at translation time and no function is created; the parameter declaration of which it is part discards the function literal. Otherwise, a function literal designates an unnamed function whose type and properties (other than its name and the corresponding linkage) are as if given by the definition syntax in the constraints. It is implementation-defined if and where a function literal with no storage-class specifiers is accepted; the admissible set of such storage-class specifiers contains static and is otherwise implementation-defined.

5 The optional attribute specifier sequence in a function literal appertains to the unnamed function. All the semantic rules for function definitions in 6.9.2 also apply to function literals.

6 Function literals are not required to designate distinct functions.

EXAMPLE 1 Function literals are expressions that provide access to anonymous functions. Their specification is kept close to where their usage occurs. If needed, access to an object with automatic storage duration can be enabled by passing a pointer to it as a function parameter. If the lifetime of such an object has ended because the call to the enclosing function has ended, the use of the pointer has undefined behavior. Also, it is implementation-defined if the access to objects with automatic storage duration is limited to the current thread.

#include <stdio.h>
void for_each_file(const char* path,
                   void* data,
                   void callback(void* data, const char* filename));

int main()
{
  enum filter { ALL, SMALL } options = ALL;  /* automatic storage duration */
  ...
  for_each_file("c:",
                &options,
                (static void (void* p, const char* file_name)){
                   enum filter* captured = p;
                   if (*captured == ALL) { /*do something*/ }
                });
}

EXAMPLE 2 If the transferred data has allocated storage duration, the call of the function literal is independent of the context in which the function literal occurs, such as whether the enclosing function call already has been terminated or whether the call to the function literal happens within another thread.

#include <stdio.h>
#include <stdlib.h>

void async(void * data, void callback(void * data));

int main()
{
  int * capture = calloc(1, sizeof *capture); /* allocated storage duration */
  *capture  = 123;
  ...
  async(capture,
        (static void (void* data)){
           int* p = data;
           printf("value=%d\n",*p);
           free(p);
        });
}

EXAMPLE 3 In the following code a type-genetric macro is implemented with a function literal. SWAP_LITERAL produces an unnamed function designator that has the sought parameter types. This is used to produce a function pointer swapd of type void (*)(double*, double*) and a type-generic macro SWAP.

#define SWAP_LITERAL(a, b)                           \
 (static void (typeof(a)* arg1, typeof(b)* arg2)) {  \
   typeof(*arg1) temp = *arg1;                       \
   *arg1 = *arg2;                                    \
   *arg2 = temp;                                     \
 }

void (*const swapd)(double*, double*) = SWAP_LITERAL(0.0, 0.0);

#define SWAP(a, b) SWAP_LITERAL(*(a), *(b))((a), (b))

int main()
{
   double A = 1.0;
   double B = 2.0;
   swapd(&A, &B);
   int a = 1;
   int b = 2;
   SWAP(&a, &b);
}