Hi Martin,

> Date: 2026-10-22 22:01:17+0200
> From: Alejandro Colomar <alx+linux-man@kernel.org>
>
[...]
> >  I still do not like it, as the fully developed form
> > would be a major pain for most C compiler to implement, but
> > I guess a restricted version would be ok.  Unfortunately, this
> > syntax does not work today, so could be used in code only at
> > some point in the future. 

This syntax is useless for us.  We have several functions that need to
write expressions in array lengths, and not just identifiers.  We even
dereference some pointer types (see getsockopt(2), lfind(3), and
lsearch(3)).

It's also useless for me as a programmer, since I need to do non-trivial
stuff in my array sizes.  Whatever we add to the language should work
for arbitrary types and expressions.

Here's a list of functions we have documented and which need a
non-restricted feature.

     long get_mempolicy(unsigned long maxnode;
                        int *mode,
                        unsigned long nodemask[(maxnode + ULONG_WIDTH - 1)
                                               / ULONG_WIDTH],
                        unsigned long maxnode, void *addr,
                        unsigned long flags);

     char *inet_net_ntop(int bits, size_t psize;
                       int af,
                       const void netp[(bits - CHAR_BIT + 1) / CHAR_BIT],
                       int bits,
                       char pres[psize], size_t psize);

     int getsockopt(socklen_t *restrict optlen;
                    int sockfd, int level, int optname,
                    void optval[_Nullable restrict *optlen],
                    socklen_t *restrict optlen);

     void *bsearch(size_t n, size_t size;
                   const void key[size], const void base[size * n],
                   size_t n, size_t size,
                   typeof(int (const void [size], const void [size]))
                       *compar);

     /* In SCO OpenServer */
     void cfree(unsigned int n, unsigned int size;
                char ptr[size * n], unsigned int n, unsigned int size);

     /* In Solaris watchmalloc.so.1 */
     void cfree(size_t n, size_t size;
                void ptr[size * n], size_t n, size_t size);

     size_t fread(size_t size, size_t n;
                  void ptr[restrict size * n],
                  size_t size, size_t n,
                  FILE *restrict stream);
     size_t fwrite(size_t size, size_t n;
                  const void ptr[restrict size * n],
                  size_t size, size_t n,
                  FILE *restrict stream);

     size_t fread_unlocked(size_t size, size_t n;
                           void ptr[restrict size * n],
                           size_t size, size_t n,
                           FILE *restrict stream);
     size_t fwrite_unlocked(size_t size, size_t n;
                           const void ptr[restrict size * n],
                           size_t size, size_t n,
                           FILE *restrict stream);

     void *lfind(size_t *n, size_t size;
                 const void key[size],
                 const void base[*n * size],
                 size_t *n, size_t size,
                 typeof(int (const void [size], const void [size]))
                     *compar);
     void *lsearch(size_t *n, size_t size;
                 const void key[size],
                 void base[*n * size],
                 size_t *n, size_t size,
                 typeof(int (const void [size], const void [size]))
                     *compar);

I might have missed some other functions; I think this isn't exhaustive.


Cheers,
Alex

-- 
<https://www.alejandro-colomar.es>