Rename identifiers

Author: lucic71

tests/unit/union_addrof_external.c

@@ -4,21 +4,21 @@
 #include <stdint.h>
 #include <string.h>
 
-struct header {
-  uint16_t tag;
-  uint16_t port;
-  uint32_t addr;
+struct record {
+  uint16_t code;
+  uint16_t lo;
+  uint32_t hi;
   char pad[8];
 };
 
-struct Storage {
+struct Container {
   union {
-    struct header h;
+    struct record h;
     char raw[128];
-  } buffer;
+  } view;
 };
 
-static void external_writer(void *out, size_t cap) {
+static void fill(void *out, size_t cap) {
   unsigned char src[16] = {0};
   src[0] = 2;
   src[1] = 0;
@@ -33,17 +33,17 @@ static void external_writer(void *out, size_t cap) {
 }
 
 int main(void) {
-  struct Storage s;
-  memset(&s, 0, sizeof(s));
+  struct Container c;
+  memset(&c, 0, sizeof(c));
 
-  external_writer((void *)&s.buffer, sizeof(s.buffer));
+  fill((void *)&c.view, sizeof(c.view));
 
-  assert(s.buffer.h.tag == 2);
-  assert(((unsigned char *)&s.buffer.h.port)[0] == 0x00);
-  assert(((unsigned char *)&s.buffer.h.port)[1] == 0x50);
+  assert(c.view.h.code == 2);
+  assert(((unsigned char *)&c.view.h.lo)[0] == 0x00);
+  assert(((unsigned char *)&c.view.h.lo)[1] == 0x50);
 
-  assert(s.buffer.raw[0] == 2);
-  assert((unsigned char)s.buffer.raw[3] == 0x50);
+  assert(c.view.raw[0] == 2);
+  assert((unsigned char)c.view.raw[3] == 0x50);
 
   return 0;
 }

tests/unit/union_cross_arm_cast.c

@@ -4,43 +4,43 @@
 #include <stdint.h>
 #include <string.h>
 
-struct header_a {
-  uint16_t tag;
-  char data[14];
+struct shape_a {
+  uint16_t code;
+  char pad[14];
 };
 
-struct header_b {
-  uint16_t tag;
-  uint16_t port;
-  uint32_t flags;
-  uint8_t body[16];
-  uint32_t extra;
+struct shape_b {
+  uint16_t code;
+  uint16_t lo;
+  uint32_t mid;
+  uint8_t fill[16];
+  uint32_t tail;
 };
 
-struct Storage {
+struct Container {
   unsigned int len;
   union {
-    struct header_a a;
-    struct header_b b;
+    struct shape_a a;
+    struct shape_b b;
     char raw[64];
   } u;
 };
 
 int main(void) {
-  struct Storage s;
-  memset(&s, 0, sizeof(s));
+  struct Container c;
+  memset(&c, 0, sizeof(c));
 
-  s.u.a.tag = 10;
-  s.len = sizeof(struct header_b);
+  c.u.a.code = 10;
+  c.len = sizeof(struct shape_b);
 
-  ((struct header_b *)(void *)&s.u.a)->extra = 0xDEADBEEF;
+  ((struct shape_b *)(void *)&c.u.a)->tail = 0xDEADBEEF;
 
-  assert(s.u.b.extra == 0xDEADBEEF);
-  assert(s.u.b.tag == 10);
+  assert(c.u.b.tail == 0xDEADBEEF);
+  assert(c.u.b.code == 10);
 
-  s.u.b.port = 0x1F90;
-  assert(((unsigned char *)&s.u.raw)[2] == 0x90);
-  assert(((unsigned char *)&s.u.raw)[3] == 0x1F);
+  c.u.b.lo = 0x1F90;
+  assert(((unsigned char *)&c.u.raw)[2] == 0x90);
+  assert(((unsigned char *)&c.u.raw)[3] == 0x1F);
 
   return 0;
 }

tests/unit/union_field_alignment.c

@@ -3,21 +3,21 @@
 #include <stddef.h>
 #include <stdint.h>
 
-struct chunk {
-  struct chunk *next;
+struct node {
+  struct node *next;
   union {
-    uint8_t data[1];
-    void *dummy;
+    uint8_t bytes[1];
+    void *aligner;
   } x;
 };
 
 int main(void) {
-  struct chunk c;
-  c.next = 0;
-  c.x.data[0] = 0xAB;
+  struct node n;
+  n.next = 0;
+  n.x.bytes[0] = 0xAB;
 
-  assert(c.x.data[0] == 0xAB);
-  assert(sizeof(c.x) >= sizeof(void *));
-  assert(((uintptr_t)&c.x % _Alignof(void *)) == 0);
+  assert(n.x.bytes[0] == 0xAB);
+  assert(sizeof(n.x) >= sizeof(void *));
+  assert(((uintptr_t)&n.x % _Alignof(void *)) == 0);
   return 0;
 }

tests/unit/union_flex_array_member.c

@@ -5,31 +5,31 @@
 #include <stdlib.h>
 #include <string.h>
 
-struct chunk {
-  size_t dlen;
+struct node {
+  size_t len;
   union {
-    uint8_t data[1];
-    void *dummy;
+    uint8_t bytes[1];
+    void *aligner;
   } x;
 };
 
 int main(void) {
-  size_t chunk_size = 32;
-  struct chunk *c = (struct chunk *)malloc(sizeof(struct chunk) + chunk_size);
-  c->dlen = chunk_size;
+  size_t tail_size = 32;
+  struct node *n = (struct node *)malloc(sizeof(struct node) + tail_size);
+  n->len = tail_size;
 
-  for (size_t i = 0; i < chunk_size; i++) {
-    c->x.data[i] = (uint8_t)(i & 0xFF);
+  for (size_t i = 0; i < tail_size; i++) {
+    n->x.bytes[i] = (uint8_t)(i & 0xFF);
   }
-  for (size_t i = 0; i < chunk_size; i++) {
-    assert(c->x.data[i] == (uint8_t)(i & 0xFF));
+  for (size_t i = 0; i < tail_size; i++) {
+    assert(n->x.bytes[i] == (uint8_t)(i & 0xFF));
   }
 
-  uint8_t *p = &c->x.data[10];
+  uint8_t *p = &n->x.bytes[10];
   assert(*p == 10);
   *p = 0xAA;
-  assert(c->x.data[10] == 0xAA);
+  assert(n->x.bytes[10] == 0xAA);
 
-  free(c);
+  free(n);
   return 0;
 }

tests/unit/union_memset_memcpy.c

@@ -4,52 +4,52 @@
 #include <stdint.h>
 #include <string.h>
 
-struct header_a {
-  uint16_t tag;
-  char data[14];
+struct shape_a {
+  uint16_t code;
+  char pad[14];
 };
 
-struct header_b {
-  uint16_t tag;
-  uint16_t port;
-  uint32_t addr;
-  char zero[8];
+struct shape_b {
+  uint16_t code;
+  uint16_t lo;
+  uint32_t hi;
+  char fill[8];
 };
 
-struct Storage {
+struct Container {
   union {
-    struct header_a a;
-    struct header_b b;
+    struct shape_a a;
+    struct shape_b b;
     char raw[256];
-  } buffer;
+  } view;
 };
 
 int main(void) {
-  struct Storage s;
-
-  memset(&s, 0, sizeof(s));
-  assert(s.buffer.a.tag == 0);
-  assert(s.buffer.b.port == 0);
-  assert(s.buffer.raw[0] == 0);
-  assert(s.buffer.raw[255] == 0);
-
-  unsigned char wire[16] = {0};
-  wire[0] = 2;
-  wire[2] = 0x50;
-  wire[3] = 0x00;
-  wire[4] = 0x7F;
-  wire[5] = 0x00;
-  wire[6] = 0x00;
-  wire[7] = 0x01;
+  struct Container c;
+
+  memset(&c, 0, sizeof(c));
+  assert(c.view.a.code == 0);
+  assert(c.view.b.lo == 0);
+  assert(c.view.raw[0] == 0);
+  assert(c.view.raw[255] == 0);
+
+  unsigned char src[16] = {0};
+  src[0] = 2;
+  src[2] = 0x50;
+  src[3] = 0x00;
+  src[4] = 0x7F;
+  src[5] = 0x00;
+  src[6] = 0x00;
+  src[7] = 0x01;
   size_t len = 16;
-  assert(len <= sizeof(s.buffer.raw));
-  memcpy(&s.buffer.raw, wire, len);
+  assert(len <= sizeof(c.view.raw));
+  memcpy(&c.view.raw, src, len);
 
-  assert(s.buffer.b.tag == 2);
-  assert(((unsigned char *)&s.buffer.b.port)[0] == 0x50);
+  assert(c.view.b.code == 2);
+  assert(((unsigned char *)&c.view.b.lo)[0] == 0x50);
 
-  memset(&s, 0, sizeof(s));
-  assert(s.buffer.b.tag == 0);
+  memset(&c, 0, sizeof(c));
+  assert(c.view.b.code == 0);
 
   return 0;
 }

tests/unit/union_nested.c

@@ -3,25 +3,25 @@
 #include <stdint.h>
 #include <string.h>
 
-struct header {
-  uint16_t tag;
-  char data[14];
+struct record {
+  uint16_t code;
+  char pad[14];
 };
 
 struct inner {
   union {
-    struct header h;
+    struct record h;
     char raw[128];
-  } buffer;
+  } view;
 };
 
 struct Outer {
   int kind;
-  int subtype;
-  int proto;
+  int level;
+  int variant;
   unsigned int len;
   union {
-    struct header h;
+    struct record h;
     struct inner nested;
   } body;
 };
@@ -31,15 +31,15 @@ int main(void) {
   memset(&ex, 0, sizeof(ex));
 
   ex.kind = 2;
-  ex.subtype = 1;
-  ex.proto = 6;
-  ex.len = sizeof(struct header);
-  ex.body.h.tag = 2;
-  ex.body.h.data[0] = 'X';
+  ex.level = 1;
+  ex.variant = 6;
+  ex.len = sizeof(struct record);
+  ex.body.h.code = 2;
+  ex.body.h.pad[0] = 'X';
 
-  assert(ex.body.h.tag == 2);
-  assert(ex.body.h.data[0] == 'X');
+  assert(ex.body.h.code == 2);
+  assert(ex.body.h.pad[0] == 'X');
 
-  assert(ex.body.nested.buffer.h.tag == 2);
+  assert(ex.body.nested.view.h.code == 2);
   return 0;
 }

tests/unit/union_pointer_pun_writethrough.c

@@ -5,12 +5,12 @@ int main(void) {
   long x = -1;
 
   union {
-    unsigned long *to_ulong;
-    long *to_long;
-  } lptr;
+    unsigned long *as_unsigned;
+    long *as_signed;
+  } pp;
 
-  lptr.to_long = &x;
-  *lptr.to_ulong = 42UL;
+  pp.as_signed = &x;
+  *pp.as_unsigned = 42UL;
 
   assert(x == 42);
   return 0;