cp assembling environment

diff --git a/README.md b/README.md
index e505925..c739da3 100644 (file)
--- a/README.md
+++ b/README.md
@@ -1,6 +1,3 @@
-# subu
-subservient user tools
 
-Create and run sub-users that share the desktop, but are limited to by unix permission to viewing their own files.
+release directory has some resources that are shared among projects
 
-see development/documents/subu.html for a more info.
\ No newline at end of file

diff --git a/developer/C/server.cli.c b/developer/C/server.cli.c
new file mode 100644 (file)
index 0000000..78a56ee
--- /dev/null
+++ b/developer/C/server.cli.c
@@ -0,0 +1,30 @@
+/*
+ * This command implements a simple Unix domain socket server.
+ * 
+ * Usage:
+ *   server
+ *
+ * Description:
+ *   This program creates a Unix domain socket at the specified path
+ *   (defined in `server.lib.c`) and listens for incoming connections. 
+ *   When a client sends data, the server logs it to a file and echoes 
+ *   a receipt. The server runs until interrupted or an error occurs.
+ * 
+ * Command-line Options and Arguments:
+ *   None: The program is self-contained and does not accept any
+ *   command-line arguments. All configuration is handled within
+ *   the implementation.
+ */
+
+#define IFACE
+#include <stdio.h>
+#include <stdlib.h>
+#include "server.lib.c"
+
+int main(int argc, char *argv[]) {
+  (void)argc; // Suppress unused variable warnings
+  (void)argv;
+
+  // Call the core server function
+  return Server·run();
+}

diff --git a/developer/C/server.lib.c b/developer/C/server.lib.c
new file mode 100644 (file)
index 0000000..144c3de
--- /dev/null
+++ b/developer/C/server.lib.c
@@ -0,0 +1,102 @@
+#ifndef IFACE
+#define Server·IMPLEMENTATION
+#define IFACE
+#endif
+
+#ifndef Server·IFACE
+#define Server·IFACE
+
+  // Necessary interface includes
+  #include <sys/socket.h>
+  #include <sys/un.h>
+  #include <stddef.h>
+
+  // Interface prototypes
+  int Server·run();
+
+#endif // Server·IFACE
+
+#ifdef Server·IMPLEMENTATION
+
+  // Implementation-specific includes
+  #include <stdio.h>
+  #include <stdlib.h>
+  #include <string.h>
+  #include <unistd.h>
+  #include <errno.h>
+
+  // Constants
+  #define Server·SOCKET_PATH "mockup/subu_server_home/subu_server.sock"
+  #define Server·LOG_PATH "mockup/subu_server_home/server.log"
+  #define Server·BUFFER_SIZE 256
+
+  int Server·run() {
+    int server_fd, client_fd;
+    struct sockaddr_un address;
+    char buffer[Server·BUFFER_SIZE];
+    FILE *log_file;
+
+    // Open the log file
+    log_file = fopen(Server·LOG_PATH, "a");
+    if (log_file == NULL) {
+      perror("Error opening log file");
+      return EXIT_FAILURE;
+    }
+
+    // Create the socket
+    if ((server_fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+      perror("Error creating socket");
+      fclose(log_file);
+      return EXIT_FAILURE;
+    }
+
+    // Configure socket address
+    memset(&address, 0, sizeof(address));
+    address.sun_family = AF_UNIX;
+    strncpy(address.sun_path, Server·SOCKET_PATH, sizeof(address.sun_path) - 1);
+
+    // Bind the socket
+    unlink(Server·SOCKET_PATH); // Remove existing file if present
+    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) == -1) {
+      perror("Error binding socket");
+      fclose(log_file);
+      close(server_fd);
+      return EXIT_FAILURE;
+    }
+
+    // Listen for connections
+    if (listen(server_fd, 5) == -1) {
+      perror("Error listening on socket");
+      fclose(log_file);
+      close(server_fd);
+      return EXIT_FAILURE;
+    }
+
+    printf("Server running, waiting for connections...\n");
+
+    // Accept and handle client connections
+    while ((client_fd = accept(server_fd, NULL, NULL)) != -1) {
+      ssize_t bytes_read;
+
+      memset(buffer, 0, Server·BUFFER_SIZE);
+      bytes_read = read(client_fd, buffer, Server·BUFFER_SIZE - 1);
+      if (bytes_read > 0) {
+        fprintf(log_file, "Received: %s\n", buffer);
+        fflush(log_file);
+      } else if (bytes_read == -1) {
+        perror("Error reading from client");
+      }
+
+      close(client_fd);
+    }
+
+    // Clean up
+    perror("Error accepting connection");
+    fclose(log_file);
+    close(server_fd);
+    unlink(Server·SOCKET_PATH);
+
+    return EXIT_FAILURE;
+  }
+
+#endif // Server·IMPLEMENTATION

diff --git a/developer/a.out b/developer/a.out
new file mode 100755 (executable)
index 0000000..771510f
Binary files /dev/null and b/developer/a.out differ

diff --git a/developer/document/RT C coding conventions.html b/developer/document/RT C coding conventions.html
new file mode 100644 (file)
index 0000000..5c0005d
--- /dev/null
+++ b/developer/document/RT C coding conventions.html
@@ -0,0 +1,153 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link href="https://fonts.googleapis.com/css2?family=Noto+Sans+JP&display=swap" rel="stylesheet">
+  <title>RT C coding conventions</title>
+  <style>
+    body {
+      font-family: 'Noto Sans JP', Arial, sans-serif;
+      background-color: hsl(0, 0%, 0%);
+      color: hsl(42, 100%, 80%);
+      padding: 2rem;
+    }
+    .page {
+      padding: 3rem;
+      margin: 1.25rem auto;
+      max-width: 46.875rem;
+      background-color: hsl(0, 0%, 0%);
+      box-shadow: 0 0 0.625rem hsl(42, 100%, 50%);
+    }
+    h1 {
+      font-size: 1.5rem;
+      text-align: center;
+      color: hsl(42, 100%, 84%);
+      text-transform: uppercase;
+      margin-top: 1.5rem;
+    }
+    h2 {
+      font-size: 1.25rem;
+      color: hsl(42, 100%, 84%);
+      text-align: center;
+      margin-top: 2rem;
+    }
+    h3 {
+      font-size: 1.125rem;
+      color: hsl(42, 100%, 75%);
+      margin-top: 1.5rem;
+    }
+    p, li {
+      color: hsl(42, 100%, 90%);
+      text-align: justify;
+      margin-bottom: 1rem;
+    }
+    code {
+      font-family: 'Courier New', Courier, monospace;
+      background-color: hsl(0, 0%, 25%);
+      padding: 0.125rem 0.25rem;
+      color: hsl(42, 100%, 90%);
+    }
+  </style>
+</head>
+
+<body>
+<div class="page">
+  <header>
+    <h1>Reasoning Technology (RT) C coding conventions</h1>
+    <p>© 2024 Thomas Walker Lynch - All Rights Reserved.</p>
+  </header>
+
+  <h2>Introduction</h2>
+
+  <p>This document summarizes some of the coding conventions used in RT C projects. Discussed here are conventions for integrated header designs, ad hoc namespaces, and a structured approach to source file extensions. The document also outlines the associated build process using a standardized makefile.</p>
+
+  <h2>Header file integration</h2>
+
+  <p>RT C projects adopt an innovative approach by integrating headers directly into source files. This ensures consistency between interfaces and implementations, eliminating mismatches. Each file contains both an interface and an implementation section, gated by preprocessor directives.</p>
+
+  <p>Each RT C source file integrates its header directly into the source file. This locality makes header content easier to maintain as everything is found in a single file. It also eliminates the need to maintain two files for each module.</p>
+
+  <h3>Each file has two sections</h3>
+  <ul>
+    <li><strong>Interface section:</strong> Contains declarations, macros, and <code>#includes</code> needed for the interface. Ensures consistency by defining the interface exactly once, even when the file is included multiple times.</li>
+    <li><strong>Implementation section:</strong> Contains function definitions and additional includes needed for the implementation. This section is compiled only when the file is used as an implementation.</li>
+  </ul>
+
+  <p>Each section is turned on and off with the CPP macro <code>IFACE</code>.</p>
+
+  <h3>Example</h3>
+  <pre><code>
+// If not an IFACE, then an IMPLEMENTATION
+#ifndef IFACE
+  #define MyModule·IMPLEMENTATION
+  // Ensures included files are processed for their interfaces.
+  #define IFACE
+#endif
+
+// Define the interface exactly once.
+#ifndef MyModule·IFACE
+#define MyModule·IFACE
+  // Interface-only includes go here.
+  void MyModule·function();
+#endif
+
+#ifdef MyModule·IMPLEMENTATION
+  // Additional includes for implementation go here.
+  #include <stdio.h>
+  void MyModule·function() {
+    printf("Hello, World!\n");
+  }
+#endif
+  </code></pre>
+
+  <h3>Explanation</h3>
+  <p>The example above demonstrates the structure and purpose of each block:</p>
+  <p><strong>First block:</strong> Ensures that the file operates correctly based on the value of <code>IFACE</code>. If <code>IFACE</code> is undefined, it defines <code>MyModule·IMPLEMENTATION</code> to enable the implementation section and sets <code>IFACE</code> to ensure subsequent includes process interface sections.</p>
+  <p><strong>Second block:</strong> Defines the interface, including declarations and interface-specific includes. The <code>#ifndef MyModule·IFACE</code> macro ensures the interface is defined exactly once, regardless of how many times the file is included.</p>
+  <p><strong>Third block:</strong> Contains implementation-specific includes and function definitions. Guarded by <code>MyModule·IMPLEMENTATION</code>, it is only included when compiling the implementation.</p>
+  <p>Interface includes are placed in the interface block, ensuring they are available wherever the interface is used. Implementation includes are isolated in the implementation block, minimizing unnecessary dependencies in other files.</p>
+
+  <h2>Namespace conventions</h2>
+  <p>RT projects use ad hoc namespaces to maintain clarity and prevent naming conflicts. This is achieved by prefixing exported identifiers with a module-specific name followed by the <code>·</code> (cdot) character.</p>
+
+  <h3>Conventions</h3>
+  <ul>
+    <li><strong>Prefix:</strong> The module name serves as the prefix, ensuring all identifiers are unique across the program.</li>
+    <li><strong>Separator:</strong> The <code>·</code> character visually separates the prefix from the identifier name, maintaining readability and avoiding conflicts.</li>
+  </ul>
+
+  <h3>Example</h3>
+  <pre><code>
+void Server·run();
+  </code></pre>
+
+  <h2>Source file extensions</h2>
+  <p>RT projects use standardized extensions to distinguish between library and command-line interface (CLI) source files:</p>
+  <ul>
+    <li><strong><code>.lib.c</code>:</strong> Files implementing library functions.</li>
+    <li><strong><code>.cli.c</code>:</strong> Files implementing command-line tools.</li>
+  </ul>
+
+  <p>The <code>.lib.c</code> files compile into libraries, while <code>.cli.c</code> files compile into standalone executables. The makefile processes these files automatically, ensuring a clear separation of functionality.</p>
+
+  <h3>Build process</h3>
+  <p>The build process follows these steps:</p>
+  <ol>
+    <li><strong>Dependency generation:</strong> Run <code>make dependency</code> to create dependencies. This step is only required when the dependency structure changes.</li>
+    <li><strong>Compilation:</strong> Run <code>make cli</code> to compile CLI sources and link them against the library. The makefile automatically manages targets and dependencies.</li>
+  </ol>
+
+  <h2>Benefits</h2>
+  <ul>
+    <li><strong>Consistency:</strong> Integrated headers ensure interface and implementation are always in sync.</li>
+    <li><strong>Modularity:</strong> Each file encapsulates its interface and implementation, reducing coupling.</li>
+    <li><strong>Clarity:</strong> Ad hoc namespaces and standardized extensions improve readability and organization.</li>
+    <li><strong>Efficiency:</strong> The makefile automates builds, minimizing errors and streamlining development.</li>
+  </ul>
+
+  <h2>Conclusion</h2>
+  <p>This document outlines the conventions and practices for writing and building RT C projects. By integrating headers, adopting namespaces, and standardizing extensions, RT ensures its projects are robust, modular, and easy to maintain.</p>
+</div>
+</body>
+</html>

diff --git a/developer/tool/make b/developer/tool/make
new file mode 100755 (executable)
index 0000000..5ab34eb
--- /dev/null
+++ b/developer/tool/make
@@ -0,0 +1,6 @@
+#!/bin/env /bin/bash
+
+set -e
+cd ${REPO_HOME}/developer
+/bin/make -f tool/makefile $@
+

diff --git a/developer/tool/makefile b/developer/tool/makefile
new file mode 100644 (file)
index 0000000..e2af188
--- /dev/null
+++ b/developer/tool/makefile
@@ -0,0 +1,18 @@
+# /bin/make must be run from $REPO_HOME/developer
+
+RESOURCE := $(REPO_HOME)/tool_shared/third_party/resource/release/make
+include $(RESOURCE)/makefile-environment
+
+# overriding defaults
+EXECDIR=mockup/subu_server_home
+LIBDIR=scratchpad
+
+# assign a compiler to use
+C=gcc
+CFLAGS= -include "$(RESOURCE)/environment.h" -std=gnu18 -Werror -O0 -ggdb -DDEBUG -DDEBUGDB -I$(INCDIR) 
+LINKFLAGS=-L$(LIBDIR) -L/usr/lib -L/usr/lib64 -l$(PROJECT)
+
+# Import the rules. The dash prefix means to ignore include errors. This is
+# required because the DEPFILE might not exist yet.
+-include $(DEPFILE)
+include $(RESOURCE)/makefile