From: Thomas Walker Lynch <eknp9n@reasoningtechnology.com>
Date: Sat, 14 Jun 2025 10:45:10 +0000 (-0700)
Subject: misc
X-Git-Url: https://git.reasoningtechnology.com/style/static/git-logo.png?a=commitdiff_plain;h=167a91e33a637bb95b3fdfa9a47bd483bbbeb6bb;p=N

misc
---

diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..59f223e
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1 @@
+Copyright © 2025 Thomas Walker Lynch - All Rights Reserved
diff --git a/LICENSE.txt b/LICENSE.txt
deleted file mode 100644
index 59f223e..0000000
--- a/LICENSE.txt
+++ /dev/null
@@ -1 +0,0 @@
-Copyright © 2025 Thomas Walker Lynch - All Rights Reserved
diff --git "a/developer/document\360\237\226\211/set_list.org" "b/developer/document\360\237\226\211/set_list.org"
new file mode 100644
index 0000000..fa12a7a
--- /dev/null
+++ "b/developer/document\360\237\226\211/set_list.org"
@@ -0,0 +1,123 @@
+\#+TITLE: Using `#assign` to Construct Sets and Lists in the C Preprocessor
+\#+AUTHOR: Thomas Walker Lynch
+\#+DATE: 2025-05-06
+\#+OPTIONS: toc\:nil num\:nil
+\#+LANGUAGE: en
+
+The `#assign` directive allows the programmer to perform runtime macro redefinitions within the C preprocessor. This facility introduces mutability and symbolic indirection, enabling set and list representations not possible with static `#define`s alone.
+
+* Introduction
+
+Normally, the C preprocessor (`cpp`) operates as a single-pass, immutable macro expander. Once a macro is defined, it cannot be updated or re-bound without manual `#undef` intervention, and even then only in certain contexts. `#assign`, by design, bypasses this constraint.
+
+It enables symbolic mutation. With this, we can simulate associative data structures: sets, lists, cons cells, even environments.
+
+* Representing Sets with `#assign`
+
+In a conventional C macro environment, a set cannot be constructed dynamically because macro definitions are static. However, with `#assign`, we can model a set as a collection of defined macro names.
+
+\*\* Membership Test
+
+To test whether `X` is in a set:
+
+\#+begin\_src c
+\#ifndef \_SET\_\_X
+\#define NOT\_MEMBER
+\#else
+\#define MEMBER
+\#endif
+\#+end\_src
+
+We treat the existence of the macro `_SET__X` as a membership marker.
+
+\*\* Adding to the Set
+
+We can define an element by assigning an empty macro:
+
+\#+begin\_src c
+\#assign (\_SET\_\_X, )
+\#+end\_src
+
+This simulates inserting `X` into the set.
+
+\*\* Properties
+
+* Sets are /existence-based/: their content is inferred by symbol presence, not enumeration.
+* There is /no inherent order/ to the elements.
+* You /cannot enumerate/ the contents of the set without external bookkeeping.
+
+- Representing Lists with `#assign`
+
+Lists can be represented as chained macros where each node is a pair (a cons cell):
+
+\#+begin\_src c
+\#define c0 (a, b)
+\#define c1 (c, d)
+\#assign (SECOND(c0), c1)
+\#define c2 (e, f)
+\#assign (SECOND(c1), c2)
+\#+end\_src
+
+This forms a chain:
+
+\#+begin\_src
+c0 → (a, c1)
+c1 → (c, c2)
+c2 → (e, f)
+\#+end\_src
+
+Each assignment updates the /cdr/ or /tail/ of the previous node.
+
+\*\* Appending to a List
+
+Given a head macro `LIST`, we can append by updating its tail pointer:
+
+\#+begin\_src c
+\#assign (LIST, CAT(LIST, COMMA, NEW\_ELEMENT))
+\#+end\_src
+
+This mutates the list structure dynamically.
+
+\*\* Traversal
+
+Traversal is only possible if a symbolic walk is encoded or if a confederate macro is prepared to test known elements. This is limited and requires foreknowledge of the structure.
+
+* Sideways Lists (Symbol Table Indexed)
+
+An alternative to comma-based lists is to use macro names as nodes — each symbol representing a cons cell.
+
+You define each cons cell:
+
+\#+begin\_src c
+\#assign (\_cons\_a, (A, \_cons\_b))
+\#assign (\_cons\_b, (B, \_cons\_c))
+\#assign (\_cons\_c, (C, NIL))
+\#+end\_src
+
+Now `_cons_a` is the symbolic head. Each macro name points to a `(car, cdr)` pair.
+
+This format mirrors the representation of linked lists in Lisp, and mutation is achieved by re-assigning the `cdr` field via `#assign`.
+
+* Mutability
+
+What makes this all possible is that `#assign` allows redefinition. It effectively simulates mutable variables:
+
+\#+begin\_src c
+\#assign (X, 5)
+\#assign (X, 7)
+\#+end\_src
+
+Later macro expansions of `X` now yield `7`, not `5`. This is unlike `#define`, which would have required an `#undef` first and would have affected macro hygiene.
+
+* Limitations
+
+- No native enumeration of keys in the symbol table.
+- No stack or heap — only symbolic references.
+- No scoped environments unless explicitly constructed via naming schemes.
+- Risk of name collisions.
+
+* Conclusion
+
+The `#assign` directive reimagines the C preprocessor as a mutable symbolic computation engine. It opens the door to implementing symbolic sets, lists, and even cons structures within macro space, turning what is normally a static templating tool into a dynamic environment for structured symbolic logic.
+
+Future extensions could include associative maps, recursive evaluators, or stack machines — all using nothing but macro indirection and symbolic mutation.
diff --git a/developer/experiment/temp.c b/developer/experiment/temp.c
new file mode 100644
index 0000000..3b8a4af
--- /dev/null
+++ b/developer/experiment/temp.c
@@ -0,0 +1,273 @@
+
+typedef long unsigned int size_t;
+typedef __builtin_va_list __gnuc_va_list;
+typedef unsigned char __u_char;
+typedef unsigned short int __u_short;
+typedef unsigned int __u_int;
+typedef unsigned long int __u_long;
+typedef signed char __int8_t;
+typedef unsigned char __uint8_t;
+typedef signed short int __int16_t;
+typedef unsigned short int __uint16_t;
+typedef signed int __int32_t;
+typedef unsigned int __uint32_t;
+typedef signed long int __int64_t;
+typedef unsigned long int __uint64_t;
+typedef __int8_t __int_least8_t;
+typedef __uint8_t __uint_least8_t;
+typedef __int16_t __int_least16_t;
+typedef __uint16_t __uint_least16_t;
+typedef __int32_t __int_least32_t;
+typedef __uint32_t __uint_least32_t;
+typedef __int64_t __int_least64_t;
+typedef __uint64_t __uint_least64_t;
+typedef long int __quad_t;
+typedef unsigned long int __u_quad_t;
+typedef long int __intmax_t;
+typedef unsigned long int __uintmax_t;
+typedef unsigned long int __dev_t;
+typedef unsigned int __uid_t;
+typedef unsigned int __gid_t;
+typedef unsigned long int __ino_t;
+typedef unsigned long int __ino64_t;
+typedef unsigned int __mode_t;
+typedef unsigned long int __nlink_t;
+typedef long int __off_t;
+typedef long int __off64_t;
+typedef int __pid_t;
+typedef struct { int __val[2]; } __fsid_t;
+typedef long int __clock_t;
+typedef unsigned long int __rlim_t;
+typedef unsigned long int __rlim64_t;
+typedef unsigned int __id_t;
+typedef long int __time_t;
+typedef unsigned int __useconds_t;
+typedef long int __suseconds_t;
+typedef long int __suseconds64_t;
+typedef int __daddr_t;
+typedef int __key_t;
+typedef int __clockid_t;
+typedef void * __timer_t;
+typedef long int __blksize_t;
+typedef long int __blkcnt_t;
+typedef long int __blkcnt64_t;
+typedef unsigned long int __fsblkcnt_t;
+typedef unsigned long int __fsblkcnt64_t;
+typedef unsigned long int __fsfilcnt_t;
+typedef unsigned long int __fsfilcnt64_t;
+typedef long int __fsword_t;
+typedef long int __ssize_t;
+typedef long int __syscall_slong_t;
+typedef unsigned long int __syscall_ulong_t;
+typedef __off64_t __loff_t;
+typedef char *__caddr_t;
+typedef long int __intptr_t;
+typedef unsigned int __socklen_t;
+typedef int __sig_atomic_t;
+typedef struct
+{
+  int __count;
+  union
+  {
+    unsigned int __wch;
+    char __wchb[4];
+  } __value;
+} __mbstate_t;
+typedef struct _G_fpos_t
+{
+  __off_t __pos;
+  __mbstate_t __state;
+} __fpos_t;
+typedef struct _G_fpos64_t
+{
+  __off64_t __pos;
+  __mbstate_t __state;
+} __fpos64_t;
+struct _IO_FILE;
+typedef struct _IO_FILE __FILE;
+struct _IO_FILE;
+typedef struct _IO_FILE FILE;
+struct _IO_FILE;
+struct _IO_marker;
+struct _IO_codecvt;
+struct _IO_wide_data;
+typedef void _IO_lock_t;
+struct _IO_FILE
+{
+  int _flags;
+  char *_IO_read_ptr;
+  char *_IO_read_end;
+  char *_IO_read_base;
+  char *_IO_write_base;
+  char *_IO_write_ptr;
+  char *_IO_write_end;
+  char *_IO_buf_base;
+  char *_IO_buf_end;
+  char *_IO_save_base;
+  char *_IO_backup_base;
+  char *_IO_save_end;
+  struct _IO_marker *_markers;
+  struct _IO_FILE *_chain;
+  int _fileno;
+  int _flags2;
+  __off_t _old_offset;
+  unsigned short _cur_column;
+  signed char _vtable_offset;
+  char _shortbuf[1];
+  _IO_lock_t *_lock;
+  __off64_t _offset;
+  struct _IO_codecvt *_codecvt;
+  struct _IO_wide_data *_wide_data;
+  struct _IO_FILE *_freeres_list;
+  void *_freeres_buf;
+  size_t __pad5;
+  int _mode;
+  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
+};
+typedef __gnuc_va_list va_list;
+typedef __off_t off_t;
+typedef __ssize_t ssize_t;
+typedef __fpos_t fpos_t;
+extern FILE *stdin;
+extern FILE *stdout;
+extern FILE *stderr;
+extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__));
+extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__));
+extern int renameat (int __oldfd, const char *__old, int __newfd,
+       const char *__new) __attribute__ ((__nothrow__ , __leaf__));
+extern int fclose (FILE *__stream);
+extern FILE *tmpfile (void)
+  __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ;
+extern char *tmpnam (char[20]) __attribute__ ((__nothrow__ , __leaf__)) ;
+extern char *tmpnam_r (char __s[20]) __attribute__ ((__nothrow__ , __leaf__)) ;
+extern char *tempnam (const char *__dir, const char *__pfx)
+   __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (__builtin_free, 1)));
+extern int fflush (FILE *__stream);
+extern int fflush_unlocked (FILE *__stream);
+extern FILE *fopen (const char *__restrict __filename,
+      const char *__restrict __modes)
+  __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ;
+extern FILE *freopen (const char *__restrict __filename,
+        const char *__restrict __modes,
+        FILE *__restrict __stream) ;
+extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__))
+  __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ;
+extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
+  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ;
+extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__))
+  __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ;
+extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
+extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
+      int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
+extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
+         size_t __size) __attribute__ ((__nothrow__ , __leaf__));
+extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
+extern int fprintf (FILE *__restrict __stream,
+      const char *__restrict __format, ...);
+extern int printf (const char *__restrict __format, ...);
+extern int sprintf (char *__restrict __s,
+      const char *__restrict __format, ...) __attribute__ ((__nothrow__));
+extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg);
+extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
+extern int vsprintf (char *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg) __attribute__ ((__nothrow__));
+extern int snprintf (char *__restrict __s, size_t __maxlen,
+       const char *__restrict __format, ...)
+     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
+extern int vsnprintf (char *__restrict __s, size_t __maxlen,
+        const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
+extern int vdprintf (int __fd, const char *__restrict __fmt,
+       __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int dprintf (int __fd, const char *__restrict __fmt, ...)
+     __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int fscanf (FILE *__restrict __stream,
+     const char *__restrict __format, ...) ;
+extern int scanf (const char *__restrict __format, ...) ;
+extern int sscanf (const char *__restrict __s,
+     const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
+extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf") ;
+extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf") ;
+extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __asm__ ("" "__isoc99_sscanf") __attribute__ ((__nothrow__ , __leaf__));
+extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
+      __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
+extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
+extern int vsscanf (const char *__restrict __s,
+      const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
+extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
+     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
+extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
+     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
+extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vsscanf") __attribute__ ((__nothrow__ , __leaf__))
+     __attribute__ ((__format__ (__scanf__, 2, 0)));
+extern int fgetc (FILE *__stream);
+extern int getc (FILE *__stream);
+extern int getchar (void);
+extern int getc_unlocked (FILE *__stream);
+extern int getchar_unlocked (void);
+extern int fgetc_unlocked (FILE *__stream);
+extern int fputc (int __c, FILE *__stream);
+extern int putc (int __c, FILE *__stream);
+extern int putchar (int __c);
+extern int fputc_unlocked (int __c, FILE *__stream);
+extern int putc_unlocked (int __c, FILE *__stream);
+extern int putchar_unlocked (int __c);
+extern int getw (FILE *__stream);
+extern int putw (int __w, FILE *__stream);
+extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
+     __attribute__ ((__access__ (__write_only__, 1, 2)));
+extern __ssize_t __getdelim (char **__restrict __lineptr,
+                             size_t *__restrict __n, int __delimiter,
+                             FILE *__restrict __stream) ;
+extern __ssize_t getdelim (char **__restrict __lineptr,
+                           size_t *__restrict __n, int __delimiter,
+                           FILE *__restrict __stream) ;
+extern __ssize_t getline (char **__restrict __lineptr,
+                          size_t *__restrict __n,
+                          FILE *__restrict __stream) ;
+extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
+extern int puts (const char *__s);
+extern int ungetc (int __c, FILE *__stream);
+extern size_t fread (void *__restrict __ptr, size_t __size,
+       size_t __n, FILE *__restrict __stream) ;
+extern size_t fwrite (const void *__restrict __ptr, size_t __size,
+        size_t __n, FILE *__restrict __s);
+extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
+         size_t __n, FILE *__restrict __stream) ;
+extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
+          size_t __n, FILE *__restrict __stream);
+extern int fseek (FILE *__stream, long int __off, int __whence);
+extern long int ftell (FILE *__stream) ;
+extern void rewind (FILE *__stream);
+extern int fseeko (FILE *__stream, __off_t __off, int __whence);
+extern __off_t ftello (FILE *__stream) ;
+extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
+extern int fsetpos (FILE *__stream, const fpos_t *__pos);
+extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
+extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
+extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+extern void perror (const char *__s);
+extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+extern int pclose (FILE *__stream);
+extern FILE *popen (const char *__command, const char *__modes)
+  __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (pclose, 1))) ;
+extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__))
+  __attribute__ ((__access__ (__write_only__, 1)));
+extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
+extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
+extern int __uflow (FILE *);
+extern int __overflow (FILE *, int);
+
+int main(){
+  printf("X %d" ,A(C));
+}
diff --git a/developer/experiment/test_recursive_define_0.c b/developer/experiment/test_recursive_define_0.c
new file mode 100644
index 0000000..da2919a
--- /dev/null
+++ b/developer/experiment/test_recursive_define_0.c
@@ -0,0 +1,52 @@
+#include <stdio.h>
+
+
+#define X  Q()B()(C)
+#define Q() A
+#define A(x) 21
+#define B()
+
+int main(){
+  printf("X %d" ,X);
+}
+
+/*
+
+So cpp truly does walk the token list with `cpp_get_token_1(pfile, &loc);` expanding each token one by one left to right. We should be able to get the desired expansion by adding another layer of macros, so that the argument expansion catches the final A(c).
+
+2025-05-12T02:53:59Z[developer]
+Thomas-developer@StanleyPark§/home/Thomas/subu_data/developer/N/developer/experiment§
+> gcc test_recursive_define_0.c 
+test_recursive_define_0.c: In function ‘main’:
+test_recursive_define_0.c:5:13: warning: implicit declaration of function ‘A’ [-Wimplicit-function-declaration]
+    5 | #define Q() A
+      |             ^
+test_recursive_define_0.c:4:12: note: in expansion of macro ‘Q’
+    4 | #define X  Q()B()(C)
+      |            ^
+test_recursive_define_0.c:10:18: note: in expansion of macro ‘X’
+   10 |   printf("X %d" ,X);
+      |                  ^
+test_recursive_define_0.c:4:19: error: ‘C’ undeclared (first use in this function)
+    4 | #define X  Q()B()(C)
+      |                   ^
+test_recursive_define_0.c:10:18: note: in expansion of macro ‘X’
+   10 |   printf("X %d" ,X);
+      |                  ^
+test_recursive_define_0.c:4:19: note: each undeclared identifier is reported only once for each function it appears in
+    4 | #define X  Q()B()(C)
+      |                   ^
+test_recursive_define_0.c:10:18: note: in expansion of macro ‘X’
+   10 |   printf("X %d" ,X);
+      |                  ^
+
+2025-05-12T02:54:17Z[developer]
+Thomas-developer@StanleyPark§/home/Thomas/subu_data/developer/N/developer/experiment§
+> gcc -E -P test_recursive_define_0.c | tail -n 5
+extern int __overflow (FILE *, int);
+
+int main(){
+  printf("X %d" ,A(C));
+}
+
+*?
diff --git a/developer/experiment/test_recursive_define_1.c b/developer/experiment/test_recursive_define_1.c
new file mode 100644
index 0000000..a7c6335
--- /dev/null
+++ b/developer/experiment/test_recursive_define_1.c
@@ -0,0 +1,44 @@
+#include <stdio.h>
+
+
+#define X  Q()B()(C)
+#define Q() A
+#define A(x) 21
+#define B()
+
+#define P(x) x
+
+int main(){
+  printf("X %d" ,P(X));
+}
+
+/*
+2025-05-12T03:00:19Z[developer]
+Thomas-developer@StanleyPark§/home/Thomas/subu_data/developer/N/developer/experiment§
+> /bin/gcc test_recursive_define_1.c 
+
+2025-05-12T03:00:51Z[developer]
+Thomas-developer@StanleyPark§/home/Thomas/subu_data/developer/N/developer/experiment§
+> ./a.out
+X 21
+2025-05-12T03:00:55Z[developer]
+Thomas-developer@StanleyPark§/home/Thomas/subu_data/developer/N/developer/experiment§
+> gcc test_recursive_define_1.c 
+
+2025-05-12T03:01:03Z[developer]
+Thomas-developer@StanleyPark§/home/Thomas/subu_data/developer/N/developer/experiment§
+> ./a.out
+X 21
+2025-05-12T03:01:05Z[developer]
+Thomas-developer@StanleyPark§/home/Thomas/subu_data/developer/N/developer/experiment§
+> gcc -E -P test_recursive_define_1.c | tail -n 5
+extern int __overflow (FILE *, int);
+
+int main(){
+  printf("X %d" ,21);
+}
+
+2025-05-12T03:01:11Z[developer]
+Thomas-developer@StanleyPark§/home/Thomas/subu_data/developer/N/developer/experiment§
+> 
+*/
diff --git a/developer/experiment/test_recursive_define_2.c b/developer/experiment/test_recursive_define_2.c
new file mode 100644
index 0000000..ecd87cc
--- /dev/null
+++ b/developer/experiment/test_recursive_define_2.c
@@ -0,0 +1,58 @@
+#include <stdio.h>
+
+
+#define X  Q()B()(C)
+#define Q() A
+#define A(x) 21
+#define B()
+
+#define P X
+
+int main(){
+  printf("X %d" ,P);
+}
+
+/*
+  This does not work because it does not cause an argument evaluation, as did test_recursive_define_1.c
+
+2025-05-12T03:01:11Z[developer]
+Thomas-developer@StanleyPark§/home/Thomas/subu_data/developer/N/developer/experiment§
+> gcc test_recursive_define_2.c 
+test_recursive_define_2.c: In function ‘main’:
+test_recursive_define_2.c:5:13: warning: implicit declaration of function ‘A’ [-Wimplicit-function-declaration]
+    5 | #define Q() A
+      |             ^
+test_recursive_define_2.c:4:12: note: in expansion of macro ‘Q’
+    4 | #define X  Q()B()(C)
+      |            ^
+test_recursive_define_2.c:9:11: note: in expansion of macro ‘X’
+    9 | #define P X
+      |           ^
+test_recursive_define_2.c:12:18: note: in expansion of macro ‘P’
+   12 |   printf("X %d" ,P);
+      |                  ^
+test_recursive_define_2.c:4:19: error: ‘C’ undeclared (first use in this function)
+    4 | #define X  Q()B()(C)
+      |                   ^
+test_recursive_define_2.c:9:11: note: in expansion of macro ‘X’
+    9 | #define P X
+      |           ^
+test_recursive_define_2.c:12:18: note: in expansion of macro ‘P’
+   12 |   printf("X %d" ,P);
+      |                  ^
+test_recursive_define_2.c:4:19: note: each undeclared identifier is reported only once for each function it appears in
+    4 | #define X  Q()B()(C)
+      |                   ^
+test_recursive_define_2.c:9:11: note: in expansion of macro ‘X’
+    9 | #define P X
+      |           ^
+test_recursive_define_2.c:12:18: note: in expansion of macro ‘P’
+   12 |   printf("X %d" ,P);
+      |                  ^
+
+2025-05-12T03:02:36Z[developer]
+Thomas-developer@StanleyPark§/home/Thomas/subu_data/developer/N/developer/experiment§
+>
+*/
+
+  
diff --git a/developer/experiment/try_assign_0 b/developer/experiment/try_assign_0
deleted file mode 100755
index 59dea2a..0000000
Binary files a/developer/experiment/try_assign_0 and /dev/null differ
diff --git a/developer/experiment/try_assign_0.c b/developer/experiment/try_assign_0.c
deleted file mode 100644
index 1394ce8..0000000
--- a/developer/experiment/try_assign_0.c
+++ /dev/null
@@ -1,5 +0,0 @@
-#include <stdio.h>
-
-int main() {
-  return 0;
-}
diff --git a/developer/experiment/try_assign_0.o b/developer/experiment/try_assign_0.o
deleted file mode 100644
index db3aacd..0000000
Binary files a/developer/experiment/try_assign_0.o and /dev/null differ
diff --git a/developer/experiment/try_assign_0.s b/developer/experiment/try_assign_0.s
deleted file mode 100644
index 8377f2b..0000000
--- a/developer/experiment/try_assign_0.s
+++ /dev/null
@@ -1,21 +0,0 @@
-	.file	"try_assign_0.c"
-	.text
-	.globl	main
-	.type	main, @function
-main:
-.LFB0:
-	.cfi_startproc
-	pushq	%rbp
-	.cfi_def_cfa_offset 16
-	.cfi_offset 6, -16
-	movq	%rsp, %rbp
-	.cfi_def_cfa_register 6
-	movl	$0, %eax
-	popq	%rbp
-	.cfi_def_cfa 7, 8
-	ret
-	.cfi_endproc
-.LFE0:
-	.size	main, .-main
-	.ident	"GCC: (Debian 12.2.0-14) 12.2.0"
-	.section	.note.GNU-stack,"",@progbits
diff --git a/developer/experiment/try_assign_1.c b/developer/experiment/try_assign_1.c
deleted file mode 100644
index b99c08d..0000000
--- a/developer/experiment/try_assign_1.c
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <stdio.h>
-
-// Static macros
-#define VALUE 42
-#define OTHER 99
-#define JOIN(a, b) a##b
-#define SUFFIX ID
-
-// Symbolic macro name and value
-#define NAME myvar
-
-// Assign dynamically: #define myvar 42
-#assign(NAME, VALUE)
-
-// Assign dynamically: #define pre_ID 99
-#assign(JOIN(pre_, SUFFIX), OTHER)
-
-int main(void)
-{
-    // Check that macros were defined
-    printf("myvar: %d\n", myvar);         // Should print 42
-    printf("pre_ID: %d\n", pre_ID);       // Should print 99
-
-    return 0;
-}
diff --git a/developer/experiment/try_assign_1.make b/developer/experiment/try_assign_1.make
deleted file mode 100644
index 79a4fc5..0000000
--- a/developer/experiment/try_assign_1.make
+++ /dev/null
@@ -1,19 +0,0 @@
-1. To see preprocessor output:
-
-gcc -E try_assign.c
-
-You should see:
-
-#define myvar 42
-#define pre_ID 99
-
-2. To compile and run:
-
-gcc try_assign.c -o try_assign
-./try_assign
-
-Expected output:
-
-myvar: 42
-pre_ID: 99
-
diff --git a/developer/experiment/try_assign_directive.c b/developer/experiment/try_assign_directive.c
new file mode 100644
index 0000000..00d2b32
--- /dev/null
+++ b/developer/experiment/try_assign_directive.c
@@ -0,0 +1,15 @@
+#include <stdio.h>
+
+#define NAME first_assign
+#define the 42
+
+#assign (NAME)(the body)
+#assign [NAME][the 
+body
+the
+]
+
+int main(void){
+  printf("all good");
+  return 0;
+}
diff --git a/developer/experiment/try_macro_directive.c b/developer/experiment/try_macro_directive.c
new file mode 100644
index 0000000..70e6157
--- /dev/null
+++ b/developer/experiment/try_macro_directive.c
@@ -0,0 +1,49 @@
+#include <stdio.h>
+//#macro X 42
+
+  #define x 5
+
+/*
+  #macro Y(x) ((x * 51))
+  #macro Z () (3)
+*/
+
+// #macro Q(f ,...) ( printf(f ,__VA_ARGS__) )
+
+//  #macro Q(f ,...) ( printf(f ,__VA_ARGS__) 
+//  )
+
+#macro Q(f ,...)(
+ printf(f ,__VA_ARGS__) 
+)
+
+#if 0
+  // The parameter list does not get expanded when scanned, as expected, so this fails.
+  // When the parameter is set to 'Y' instead of 'y' this works.
+  #define Z 7
+  #define y Y
+  #macro P(y)(Y+Z)
+#endif
+
+#if 0
+// The body is not expanded when a macro is defined. However, to get mutliline
+// behavior we turned off the directive parsing mode, so this will be interesting
+// ...
+// Y was not expanded in the definition, so this failed at the expansion point
+// of the printf below.
+#define Y 5
+#macro R(Z)(Y+Z)
+#undef Y
+#endif
+
+int main(void){
+  //  printf("Y: %d\n", Y(3));
+  //  printf("Z: %d\n", Z());
+  Q("%x %x %x" ,1 ,2 ,3);
+  putchar('\n');
+
+  // printf("P: %d\n", P(3));
+  // printf("R: %d\n", R(11));
+
+  return 0;
+}
diff --git "a/tool_shared/bespoke\360\237\226\211/env" "b/tool_shared/bespoke\360\237\226\211/env"
index 449d8a6..917bda4 100644
--- "a/tool_shared/bespoke\360\237\226\211/env"
+++ "b/tool_shared/bespoke\360\237\226\211/env"
@@ -32,13 +32,13 @@ shopt -s nullglob
   export REPO_HOME PROJECT PROMPT_DECOR
 
 # --------------------------------------------------------------------------------
-# RT_gcc_16
+# RT_gcc
 #  note also PATH entry
 
-  export RT_gcc_16=/home/Thomas/subu_data/developer/N/tool_shared/customized/RT_gcc_16
-  export LIBRARY_PATH=$RT_gcc_16/lib
-  export C_INCLUDE_PATH=$RT_gcc_16/include
-  export LD_LIBRARY_PATH=$RT_gcc_16/lib
+  export RT_gcc=/home/Thomas/subu_data/developer/N/tool_shared/customized/RT_gcc
+  export LIBRARY_PATH=$RT_gcc/lib
+  export C_INCLUDE_PATH=$RT_gcc/include
+  export LD_LIBRARY_PATH=$RT_gcc/lib
 
 # --------------------------------------------------------------------------------
 # Other Tool roots
@@ -56,7 +56,7 @@ shopt -s nullglob
   PATH="$REPO_HOME/tool_shared/third_party/emacs/bin:$PATH"
   PATH="$REPO_HOME/tool_shared/third_party/idea-IC-243.21565.193/bin:$PATH"
   PATH="$REPO_HOME/tool_shared/third_party:$PATH"
-  PATH="$RT_gcc_16":"$PATH"
+  PATH="$RT_gcc"/bin:"$PATH"
   PATH="$REPO_HOME/tool_shared/customized:$PATH"
   PATH="$REPO_HOME"/tool_shared/bespoke🖉:"$PATH"
 
diff --git a/tool_shared/customized/RT_gcc b/tool_shared/customized/RT_gcc
new file mode 120000
index 0000000..7f02d24
--- /dev/null
+++ b/tool_shared/customized/RT_gcc
@@ -0,0 +1 @@
+/home/Thomas/subu_data/developer/RT_gcc/toolchain
\ No newline at end of file
diff --git a/tool_shared/customized/RT_gcc_16 b/tool_shared/customized/RT_gcc_16
deleted file mode 120000
index 1fd2c65..0000000
--- a/tool_shared/customized/RT_gcc_16
+++ /dev/null
@@ -1 +0,0 @@
-/home/Thomas/subu_data/developer/RT_gcc_16/install
\ No newline at end of file
diff --git "a/tool_shared/document\360\237\226\211/install.txt" "b/tool_shared/document\360\237\226\211/install.txt"
index 4f24c15..93d2b2b 100644
--- "a/tool_shared/document\360\237\226\211/install.txt"
+++ "b/tool_shared/document\360\237\226\211/install.txt"
@@ -48,15 +48,15 @@ gcc
     to multiple projects, so it is at the top level   ~/pragma_macro.
 
 
-    RT_gcc_16=/home/Thomas/subu_data/developer/N/tool_shared/customized/RT_gcc_16
+    RT_gcc=/home/Thomas/subu_data/developer/N/tool_shared/customized/RT_gcc
 
-    ln -s /home/Thomas/subu_data/developer/RT_gcc_16/install $RT_gcc_16
+    ln -s /home/Thomas/subu_data/developer/RT_gcc/toolchain $RT_gcc
 
-      PATH="$RT_gcc_16":"$PATH"
-      export PATH=$RT_gcc_16:$PATH
-      export LIBRARY_PATH=$RT_gcc_16/lib
-      export C_INCLUDE_PATH=$RT_gcc_16/include
-      export LD_LIBRARY_PATH=$RT_gcc_16/lib
+      PATH="$RT_gcc":"$PATH"
+      export PATH=$RT_gcc:$PATH
+      export LIBRARY_PATH=$RT_gcc/lib
+      export C_INCLUDE_PATH=$RT_gcc/include
+      export LD_LIBRARY_PATH=$RT_gcc/lib