Why does the C standard not mention any UB in its definition of offsetof()? Is it implicit somewhere else that doing offsetof(struct foo, arr[SIZE_MAX]) on a struct containing a flexible array member is UB?

Both GCC and clang don't diagnose anything here and compile it to a "return 0":

#include <stddef.h>
#include <inttypes.h>
struct foo {
    int a;
    int arr[];
};
unsigned long func(void) {
    return offsetof(struct foo, arr[SIZE_MAX]);
}

https://godbolt.org/z/rx7rqvh7j

Funny standard C behavior - assigning a struct with flexible array member can copy parts of the flexible array member:

$ cat vla_assign.c
#include <stdlib.h>
#include <stdio.h>
struct foo {
  long a;
  int b;
  int arr[];
};
int main(void) {
  struct foo *a = malloc(sizeof(struct foo) + sizeof(int)*3);
  struct foo *b = malloc(sizeof(struct foo) + sizeof(int)*3);
  if (!a || !b)
    return 1;

  a->a = 1;
  a->b = 2;
  for (int i=0; i<3; i++)
    a->arr[i] = i;

  b->a = 101;
  b->b = 102;
  for (int i=0; i<3; i++)
    b->arr[i] = i + 100;

  *b = *a;

  for (int i=0; i<3; i++)
    printf("%d ", b->arr[i]);
  printf("\n");
}
$ gcc -Wall -Wextra -pedantic -o vla_assign vla_assign.c
$ ./vla_assign
0 101 102

Retro C++ quiz #26

#include <cmath>

auto f(unsigned int x) {
return std::abs(x); // Well-formed?
}

Without checking:

A. Yes
B. No
C: Show answers

#cplusplus
#Cpppolls

fun Linux fact: because MAP_SHARED|MAP_ANONYMOUS is actually a file-backed mapping under the hood, unmapping part of such a mapping does not discard the data stored in that part:

$ cat mremap.c
#define _GNU_SOURCE
#include <err.h>
#include <stdio.h>
#include <sys/mman.h>
int main(void) {
  char *p = mmap(NULL, 0x2000, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
  if (p == MAP_FAILED) err(1, "mmap");
  p[0x1000] = 'X';
  if (munmap(p+0x1000, 0x1000)) err(1, "munmap");
  // that 'X' we just wrote... is it gone?
  // nope, let's bring it back!
  p = mremap(p, 0x1000, 0x2000, MREMAP_MAYMOVE);
  if (p == MAP_FAILED) err(1, "mremap");
  printf("p[0x1000]='%c'\n", p[0x1000]);
}
$ gcc -o mremap mremap.c
$ ./mremap
p[0x1000]='X'
$

Many file formats have some kinds of inclusion directive, like "#include" for C, "\input" for LaTeX, "\transclude" for forester.

I would like to have a text editor feature that allows me to visually expand an inclusion directive in the text buffer, just like how folds of text regions work, while actual changes are still made to the referenced file.

This would be very useful when working with projects with many inter-linked files because most text editors are not very good at jumping around files/buffers.
However, this feature looks impossible to implement nicely in vim. Does anyone know an editor that supports this or is hopeful to support this?

ok i hit this weekend's goal:

#include <windows.h>

int main(int argc, char **argv) {
char computer_name_buf[1024];
DWORD buf_size = sizeof(computer_name_buf);
GetComputerNameA(computer_name_buf, &buf_size);
printf("hi from main: computer name %s\n", computer_name_buf);
return 0;
}

Time to get printf to the SIZE_MAX off the ground. Especially since it's not the type that matters for the precision specifier for the string size, it's the actual value.

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

int main() {
    enum { COUNT = 10, BYTESIZE = INT_MAX / COUNT };
    char* str = (char*)malloc(BYTESIZE + 1);
    for (size_t i = 0; i < BYTESIZE; ++i) {
        str[i] = 'a';
    }
    str[BYTESIZE]                          = '\0';
    FILE* f                                = fopen("/dev/null", "w+");
    [[maybe_unused]] int write_value       = fprintf(f, "%.*s", BYTESIZE, str);
    [[maybe_unused]] int large_write_value = fprintf(f, "%.*s %*.s %*.s %*.s %*.s %*.s %*.s %*.s %*.s %*.s %*.s",
         BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str,
         BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str);
    free(str);
    assert(write_value == BYTESIZE); // Well.
    assert(large_write_value == -1); // ... Okay.
    // this should let the other thing work out nicely, then.
    return 0;
}

Wow, __builtin_dump_struct is an amazing clang feature, how did I never hear about this before?

$ cat test.c
#include <stdio.h>

struct nested {
  int n;
};
struct foo {
  int member_a;
  unsigned long member_b;
  char *str;
  void *ptr;
  struct nested nested;
};

int main(void) {
  struct foo f = {
    .member_a = 123,
    .member_b = 0x4141414141414141,
    .str = "foobar",
    .ptr = &f,
    .nested = {.n = 42}
  };
  __builtin_dump_struct(&f, printf);
}
$ clang -o test test.c && ./test
struct foo {
  int member_a = 123
  unsigned long member_b = 4702111234474983745
  char * str = "foobar"
  void * ptr = 0x7fff1df41b78
  struct nested nested = {
    int n = 42
  }
}

The original version of this feature was introduced back in 2018 (though it was reimplemented since in 2022).

If you want me to hate you forever, a good way to do this is to share sample code as a isolated function in a blockquote, which produces a dozen 'symbol not found' errors when punched into actual code because you *didn't* include a blockquote containing the half-dozen #include or `using` or `import` statements that would be needed to bring the various API calls and types you reference into scope

I am now following the hashtags #ifdef and #include