rc/README.md at bd8d9d819ed4fafca64c94b9836c13303bbf91e4

 # RC - Retoor's C Interpreter
 RC is a lightweight, recursive-descent C interpreter written in C. It executes a subset of C code directly without compilation, supporting essential language features including control flow, functions, pointers, and an extensive standard library.
 ## Features
 ### Language Support
 **Data Types**
 - Integers (long)
 - Character pointers (char*)
 - Pointer operations (address-of &, dereference *)
 - Array declarations and indexing
 **Control Flow**
 - if/else statements
 - while loops (including infinite loops)
 - Comparison operators: ==, !=, <, >, <=, >=
 - Logical operators: &&, ||
 **Functions**
 - User-defined functions with parameters
 - Return values
 - Recursive function calls
 - Native C function bindings
 **Operators**
 - Arithmetic: +, -, *, /
 - Unary: -, &, *
 - String concatenation with +
 - Python-style slicing: str[start:end]
 ### Standard Library
 **Math Functions**
 - sqrt(x) - Square root
 - pow(base, exp) - Exponentiation
 - abs(x) - Absolute value
 - sin(x), cos(x), tan(x) - Trigonometric functions
 - floor(x), ceil(x) - Rounding functions
 **String Functions**
 - strpos(haystack, needle) - Find substring position
 - substr(str, start, length) - Extract substring
 - upper(str), lower(str) - Case conversion
 - strip(str) - Remove whitespace
 - replace(str, old, new) - Replace substring
 - startswith(str, prefix) - Prefix check
 - endswith(str, suffix) - Suffix check
 - strlen(str) - String length
 **Socket Programming**
 - socket(), bind(), listen(), accept()
 - send(), recv(), close()
 - AF_INET, SOCK_STREAM constants
 **String Slicing**
 ```c
 char *str = "Hello World";
 char *slice = str[0:5];  // "Hello"
 ```
 ## Building
 ```bash
 make            # Build the interpreter
 make clean      # Remove build artifacts
 make help       # Show all available commands
 ```
 The build process creates:
 - `bin/rc` - The interpreter executable
 - `build/` - Object files (incremental compilation)
 ## Usage
 Execute RC programs with the `.rc` extension:
 ```bash
 ./bin/rc program.rc
 ```
 Or use make targets:
 ```bash
 make test                  # Run all tests
 make run-feature-test      # Run specific test
 make run-http-simple       # Run simple HTTP server example
 ```
 ## Example Programs
 ### Simple Program
 ```c
 int main() {
     int x = 10;
     int y = 20;
     printf("Sum: %d\n", x + y);
     return 0;
 }
 ```
 ### String Manipulation
 ```c
 int main() {
     char *text = "Hello World";
     char *upper_text = upper(text);
     char *slice = text[0:5];
     printf("Original: %s\n", text);
     printf("Uppercase: %s\n", upper_text);
     printf("Sliced: %s\n", slice);
     return 0;
 }
 ```
 ### HTTP Server Examples
 **Simple HTTP Server** (`examples/http_simple.rc`)
 Single-connection HTTP server that accepts one request and exits.
 **Persistent HTTP Server** (`examples/http_persistent.rc`)
 HTTP server with request counter that continuously accepts connections.
 **Multi-Connection HTTP Server** (`examples/http_multi.rc`)
 HTTP server that handles up to 100 consecutive connections.
 ## Project Structure
 ```
 rc/
 ├── src/                    # Source code
 │   ├── main.c             # Entry point
 │   ├── tokenizer.c/h      # Lexical analysis
 │   ├── parser.c/h         # Expression parsing
 │   ├── interpreter.c/h    # Statement execution
 │   ├── native_functions.c/h  # Native bindings
 │   ├── string_utils.c/h   # String utilities
 │   ├── globals.c          # Global variables
 │   └── types.h            # Type definitions
 ├── tests/                 # Test programs (.rc)
 ├── examples/              # Example programs (.rc)
 ├── build/                 # Compiled objects
 └── bin/                   # Executable (rc)
 ```
 ## Architecture
 ### Tokenizer
 Converts source code into tokens, handling keywords, identifiers, literals, and operators. Supports line comments (//) and escape sequences in strings.
 ### Parser
 Recursive-descent parser with operator precedence:
 - factor() - Literals, variables, function calls
 - unary() - Unary operators (-, &, *)
 - term() - Multiplication, division
 - add() - Addition, subtraction, string concatenation
 - relational() - Comparison operators
 - expression() - Assignments and top-level expressions
 ### Interpreter
 Direct execution model without intermediate bytecode. Uses a virtual memory array for stack and variables, with separate string pool for dynamic strings.
 ### Native Functions
 Extensible system for binding C functions. Current bindings include math operations, string manipulation, and socket programming.
 ## Limitations
 - Memory model uses long cells (not byte-accurate)
 - No support for structs, unions, or enums as user types
 - Limited type system (int and char* only)
 - No preprocessor directives
 - Error messages show token index rather than line/column
 - Pointer arithmetic works on virtual memory addresses
 ## Testing
 The project includes comprehensive test suites:
 - **feature_test.rc** - Core language features
 - **endless_loop_test.rc** - Loop constructs
 - **math_test.rc** - Mathematical operations
 - **string_test.rc** - String concatenation
 - **string_manip_test.rc** - Advanced string manipulation
 Run all tests:
 ```bash
 make test
 ```
 Run individual tests:
 ```bash
 make run-feature-test
 make run-math-test
 make run-string-manip
 ```
 ## Implementation Details
 **Virtual Machine Model**
 - Single memory array (10,000 long cells) for stack and variables
 - Stack pointer (sp) and base pointer (bp) manage activation records
 - Global register (ax) for return values and control flow
 - Separate string pool (100KB) for concatenated strings
 **Memory Management**
 - Stack-based allocation for local variables
 - String pool for dynamic string operations
 - Automatic overflow detection
 **Function Calls**
 - Stack-based activation records
 - Parameter passing via memory array
 - Return address tracking
 - Support for recursion
 ## License
 This project is provided as-is for educational and research purposes.