@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/c/examples/legacy/c89-to-c11-migration.c

@@ -0,0 +1,268 @@
+/**
+ * @file c89-to-c11-migration.c
+ * @brief Example demonstrating C89 to C11 migration patterns
+ * 
+ * This file shows before/after examples of migrating legacy C89 code
+ * to modern C11 standards while maintaining compatibility.
+ * 
+ * Compile C89: gcc -std=c89 -DUSE_C89 -o legacy c89-to-c11-migration.c
+ * Compile C11: gcc -std=c11 -o modern c89-to-c11-migration.c
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef USE_C89
+/* C89 version */
+
+#include <stddef.h>
+
+/* C89: No inline keyword */
+#define INLINE
+
+/* C89: No bool type */
+typedef int bool;
+#define true 1
+#define false 0
+
+/* C89: No restrict keyword */
+#define restrict
+
+/* C89: No stdint.h */
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+
+#else
+/* C11 version */
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#define INLINE inline
+
+#endif
+
+/**
+ * EXAMPLE 1: Variable Declarations
+ */
+
+void example_variable_declarations(void) {
+#ifdef USE_C89
+    /* C89: All declarations at start of block */
+    int i;
+    int sum = 0;
+    int array[10];
+    
+    /* Initialize array */
+    for (i = 0; i < 10; i++) {
+        array[i] = i;
+    }
+    
+    /* Calculate sum */
+    for (i = 0; i < 10; i++) {
+        sum += array[i];
+    }
+#else
+    /* C11: Declarations anywhere, loop variable in for() */
+    int sum = 0;
+    int array[10];
+    
+    /* Initialize array */
+    for (int i = 0; i < 10; i++) {
+        array[i] = i;
+    }
+    
+    /* Calculate sum - can reuse 'i' */
+    for (int i = 0; i < 10; i++) {
+        sum += array[i];
+    }
+#endif
+    
+    printf("Sum: %d\n", sum);
+}
+
+/**
+ * EXAMPLE 2: Designated Initializers
+ */
+
+typedef struct {
+    int x;
+    int y;
+    int z;
+} Point3D;
+
+void example_designated_initializers(void) {
+#ifdef USE_C89
+    /* C89: Positional initialization only */
+    Point3D p1;
+    p1.x = 10;
+    p1.y = 20;
+    p1.z = 30;
+    
+    /* Or with initializer list (must be in order) */
+    Point3D p2 = {10, 20, 30};
+#else
+    /* C11: Designated initializers (any order) */
+    Point3D p1 = {.x = 10, .y = 20, .z = 30};
+    Point3D p2 = {.z = 30, .x = 10, .y = 20};  /* Order doesn't matter */
+    Point3D p3 = {.x = 10};  /* Others default to 0 */
+#endif
+    
+    printf("Point: (%d, %d, %d)\n", p1.x, p1.y, p1.z);
+}
+
+/**
+ * EXAMPLE 3: Static Assertions
+ */
+
+void example_static_assertions(void) {
+#ifdef USE_C89
+    /* C89: Runtime assertion only */
+    if (sizeof(int) != 4) {
+        fprintf(stderr, "Error: int is not 4 bytes\n");
+        exit(1);
+    }
+#else
+    /* C11: Compile-time assertion */
+    _Static_assert(sizeof(int) == 4, "int must be 4 bytes");
+#endif
+    
+    printf("Size checks passed\n");
+}
+
+/**
+ * EXAMPLE 4: Flexible Array Members
+ */
+
+#ifdef USE_C89
+/* C89: Use array of size 1 (hack) */
+typedef struct {
+    size_t length;
+    char data[1];  /* Actually variable length */
+} Buffer_C89;
+
+Buffer_C89* create_buffer_c89(size_t size) {
+    Buffer_C89 *buf = malloc(sizeof(Buffer_C89) + size - 1);
+    if (buf) {
+        buf->length = size;
+    }
+    return buf;
+}
+#else
+/* C11: Flexible array member */
+typedef struct {
+    size_t length;
+    char data[];  /* Flexible array member */
+} Buffer_C11;
+
+Buffer_C11* create_buffer_c11(size_t size) {
+    Buffer_C11 *buf = malloc(sizeof(Buffer_C11) + size);
+    if (buf) {
+        buf->length = size;
+    }
+    return buf;
+}
+#endif
+
+/**
+ * EXAMPLE 5: Inline Functions
+ */
+
+/* C89: Use macro (no type safety) */
+#ifdef USE_C89
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#else
+/* C11: Inline function (type safe) */
+static inline int max_int(int a, int b) {
+    return a > b ? a : b;
+}
+#endif
+
+void example_inline_functions(void) {
+#ifdef USE_C89
+    int result = MAX(10, 20);
+#else
+    int result = max_int(10, 20);
+#endif
+    printf("Max: %d\n", result);
+}
+
+/**
+ * EXAMPLE 6: Anonymous Unions/Structs
+ */
+
+#ifdef USE_C89
+/* C89: Named union required */
+typedef struct {
+    int type;
+    union {
+        int i;
+        float f;
+    } value;  /* Must be named */
+} Variant_C89;
+
+void use_variant_c89(void) {
+    Variant_C89 v;
+    v.type = 1;
+    v.value.i = 42;  /* Must use union name */
+    printf("Value: %d\n", v.value.i);
+}
+#else
+/* C11: Anonymous union */
+typedef struct {
+    int type;
+    union {
+        int i;
+        float f;
+    };  /* Anonymous */
+} Variant_C11;
+
+void use_variant_c11(void) {
+    Variant_C11 v;
+    v.type = 1;
+    v.i = 42;  /* Direct access */
+    printf("Value: %d\n", v.i);
+}
+#endif
+
+/**
+ * Main function
+ */
+int main(void) {
+    printf("=== C89 to C11 Migration Examples ===\n\n");
+    
+#ifdef USE_C89
+    printf("Compiled with C89 standard\n\n");
+#else
+    printf("Compiled with C11 standard\n\n");
+#endif
+    
+    printf("Example 1: Variable Declarations\n");
+    example_variable_declarations();
+    printf("\n");
+    
+    printf("Example 2: Designated Initializers\n");
+    example_designated_initializers();
+    printf("\n");
+    
+    printf("Example 3: Static Assertions\n");
+    example_static_assertions();
+    printf("\n");
+    
+    printf("Example 5: Inline Functions\n");
+    example_inline_functions();
+    printf("\n");
+    
+#ifdef USE_C89
+    printf("Example 6: Anonymous Unions (C89)\n");
+    use_variant_c89();
+#else
+    printf("Example 6: Anonymous Unions (C11)\n");
+    use_variant_c11();
+#endif
+    
+    return 0;
+}
+

package/augment-extensions/coding-standards/c/examples/legacy/compatibility-layer.c

@@ -0,0 +1,239 @@
+/**
+ * @file compatibility-layer.c
+ * @brief Example compatibility layer for cross-platform and cross-standard code
+ * 
+ * This example demonstrates:
+ * - Platform abstraction
+ * - C standard compatibility
+ * - Compiler-specific workarounds
+ * - Feature detection
+ * - Graceful degradation
+ * 
+ * Compile: gcc -Wall -Wextra -std=c11 -o compat compatibility-layer.c
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * SECTION 1: Compiler Detection
+ */
+
+#if defined(__GNUC__)
+    #define COMPILER_GCC 1
+    #define COMPILER_NAME "GCC"
+#elif defined(_MSC_VER)
+    #define COMPILER_MSVC 1
+    #define COMPILER_NAME "MSVC"
+#elif defined(__clang__)
+    #define COMPILER_CLANG 1
+    #define COMPILER_NAME "Clang"
+#else
+    #define COMPILER_UNKNOWN 1
+    #define COMPILER_NAME "Unknown"
+#endif
+
+/**
+ * SECTION 2: Platform Detection
+ */
+
+#if defined(_WIN32) || defined(_WIN64)
+    #define PLATFORM_WINDOWS 1
+    #define PLATFORM_NAME "Windows"
+#elif defined(__linux__)
+    #define PLATFORM_LINUX 1
+    #define PLATFORM_NAME "Linux"
+#elif defined(__APPLE__)
+    #define PLATFORM_MACOS 1
+    #define PLATFORM_NAME "macOS"
+#else
+    #define PLATFORM_UNKNOWN 1
+    #define PLATFORM_NAME "Unknown"
+#endif
+
+/**
+ * SECTION 3: C Standard Detection
+ */
+
+#if __STDC_VERSION__ >= 201112L
+    #define C_STANDARD_C11 1
+    #define C_STANDARD_NAME "C11"
+#elif __STDC_VERSION__ >= 199901L
+    #define C_STANDARD_C99 1
+    #define C_STANDARD_NAME "C99"
+#else
+    #define C_STANDARD_C89 1
+    #define C_STANDARD_NAME "C89"
+#endif
+
+/**
+ * SECTION 4: Feature Compatibility Macros
+ */
+
+/* Inline keyword */
+#if defined(C_STANDARD_C99) || defined(C_STANDARD_C11)
+    #define COMPAT_INLINE inline
+#elif defined(COMPILER_GCC) || defined(COMPILER_CLANG)
+    #define COMPAT_INLINE __inline__
+#elif defined(COMPILER_MSVC)
+    #define COMPAT_INLINE __inline
+#else
+    #define COMPAT_INLINE
+#endif
+
+/* Restrict keyword */
+#if defined(C_STANDARD_C99) || defined(C_STANDARD_C11)
+    #define COMPAT_RESTRICT restrict
+#elif defined(COMPILER_GCC) || defined(COMPILER_CLANG)
+    #define COMPAT_RESTRICT __restrict__
+#elif defined(COMPILER_MSVC)
+    #define COMPAT_RESTRICT __restrict
+#else
+    #define COMPAT_RESTRICT
+#endif
+
+/* Function attributes */
+#if defined(COMPILER_GCC) || defined(COMPILER_CLANG)
+    #define COMPAT_NORETURN __attribute__((noreturn))
+    #define COMPAT_UNUSED __attribute__((unused))
+    #define COMPAT_PRINTF_FORMAT(fmt, args) __attribute__((format(printf, fmt, args)))
+#elif defined(COMPILER_MSVC)
+    #define COMPAT_NORETURN __declspec(noreturn)
+    #define COMPAT_UNUSED
+    #define COMPAT_PRINTF_FORMAT(fmt, args)
+#else
+    #define COMPAT_NORETURN
+    #define COMPAT_UNUSED
+    #define COMPAT_PRINTF_FORMAT(fmt, args)
+#endif
+
+/* Static assertion */
+#if defined(C_STANDARD_C11)
+    #define COMPAT_STATIC_ASSERT(cond, msg) _Static_assert(cond, msg)
+#elif defined(COMPILER_GCC) && __GNUC__ >= 4
+    #define COMPAT_STATIC_ASSERT(cond, msg) \
+        typedef char static_assertion_##__LINE__[(cond) ? 1 : -1]
+#else
+    #define COMPAT_STATIC_ASSERT(cond, msg)
+#endif
+
+/**
+ * SECTION 5: Type Compatibility
+ */
+
+#if defined(C_STANDARD_C99) || defined(C_STANDARD_C11)
+    #include <stdint.h>
+    #include <stdbool.h>
+#else
+    /* Provide stdint types for C89 */
+    typedef unsigned char uint8_t;
+    typedef unsigned short uint16_t;
+    typedef unsigned int uint32_t;
+    typedef signed char int8_t;
+    typedef short int16_t;
+    typedef int int32_t;
+    
+    /* Provide bool for C89 */
+    typedef int bool;
+    #define true 1
+    #define false 0
+#endif
+
+/**
+ * SECTION 6: Platform-Specific Functions
+ */
+
+#ifdef PLATFORM_WINDOWS
+    #include <windows.h>
+    
+    static COMPAT_INLINE void compat_sleep_ms(unsigned int ms) {
+        Sleep(ms);
+    }
+#else
+    #include <unistd.h>
+    
+    static COMPAT_INLINE void compat_sleep_ms(unsigned int ms) {
+        usleep(ms * 1000);
+    }
+#endif
+
+/**
+ * SECTION 7: Safe String Functions
+ */
+
+/* Safe string copy (compatible with all platforms) */
+static COMPAT_INLINE size_t compat_strlcpy(char *dst, const char *src, size_t size) {
+    size_t src_len = strlen(src);
+    
+    if (size > 0) {
+        size_t copy_len = (src_len >= size) ? size - 1 : src_len;
+        memcpy(dst, src, copy_len);
+        dst[copy_len] = '\0';
+    }
+    
+    return src_len;
+}
+
+/**
+ * SECTION 8: Example Usage
+ */
+
+/* Example function with compatibility features */
+static COMPAT_INLINE int compat_add(int a, int b) {
+    return a + b;
+}
+
+/* Example function with printf format checking */
+static void COMPAT_PRINTF_FORMAT(1, 2) compat_log(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    vprintf(format, args);
+    va_end(args);
+}
+
+/* Example noreturn function */
+static COMPAT_NORETURN void compat_fatal_error(const char *msg) {
+    fprintf(stderr, "FATAL ERROR: %s\n", msg);
+    exit(EXIT_FAILURE);
+}
+
+/**
+ * SECTION 9: Compile-Time Checks
+ */
+
+/* Verify type sizes */
+COMPAT_STATIC_ASSERT(sizeof(uint8_t) == 1, "uint8_t must be 1 byte");
+COMPAT_STATIC_ASSERT(sizeof(uint16_t) == 2, "uint16_t must be 2 bytes");
+COMPAT_STATIC_ASSERT(sizeof(uint32_t) == 4, "uint32_t must be 4 bytes");
+
+/**
+ * Main function
+ */
+int main(void) {
+    printf("=== Compatibility Layer Example ===\n\n");
+    
+    printf("Compiler: %s\n", COMPILER_NAME);
+    printf("Platform: %s\n", PLATFORM_NAME);
+    printf("C Standard: %s\n", C_STANDARD_NAME);
+    printf("\n");
+    
+    /* Test compatibility functions */
+    printf("Testing compat_add: %d\n", compat_add(10, 20));
+    
+    /* Test safe string copy */
+    char buffer[10];
+    compat_strlcpy(buffer, "Hello, World!", sizeof(buffer));
+    printf("Truncated string: %s\n", buffer);
+    
+    /* Test platform sleep */
+    printf("Sleeping for 100ms...\n");
+    compat_sleep_ms(100);
+    printf("Done!\n");
+    
+    /* Test logging */
+    compat_log("Log message: %d + %d = %d\n", 5, 3, 5 + 3);
+    
+    return EXIT_SUCCESS;
+}
+

package/augment-extensions/coding-standards/c/examples/networking/Makefile

@@ -0,0 +1,35 @@
+# Makefile for Networking Examples
+
+CC = gcc
+CFLAGS = -Wall -Wextra -Werror -std=c11 -pedantic -O2
+LDFLAGS =
+TARGETS = tcp-server udp-multicast protocol-parser
+
+.PHONY: all clean test
+
+all: $(TARGETS)
+
+tcp-server: tcp-server.c
+	$(CC) $(CFLAGS) -o $@ $< $(LDFLAGS)
+
+udp-multicast: udp-multicast.c
+	$(CC) $(CFLAGS) -o $@ $< $(LDFLAGS)
+
+protocol-parser: protocol-parser.c
+	$(CC) $(CFLAGS) -o $@ $< $(LDFLAGS)
+
+clean:
+	rm -f $(TARGETS) *.o
+
+test: all
+	@echo "Testing protocol parser..."
+	./protocol-parser
+	@echo ""
+	@echo "To test TCP server:"
+	@echo "  Terminal 1: ./tcp-server 8080"
+	@echo "  Terminal 2: telnet localhost 8080"
+	@echo ""
+	@echo "To test UDP multicast:"
+	@echo "  Terminal 1: ./udp-multicast recv 239.0.0.1 5000"
+	@echo "  Terminal 2: ./udp-multicast send 239.0.0.1 5000"
+