[Patch] Add print statement.

Author: coredex-source

Cargo.toml

@@ -3,12 +3,16 @@ name = "noviq"
 version = "0.1.0"
 edition = "2021"
 authors = ["Noviq Contributors"]
-description = "A simple, compiled programming language written in Rust"
+description = "A simple, interpreted programming language written in Rust"
 license = "GPL-3.0"
 
 [dependencies]
 chrono = "0.4"
 
+[lib]
+name = "noviq"
+path = "src/lib.rs"
+
 [[bin]]
 name = "noviq"
 path = "src/main.rs"

ORGANIZATION.md

@@ -0,0 +1,99 @@
+# Noviq Project Organization
+
+This document shows the final modular structure of the Noviq interpreter.
+
+## Directory Structure
+
+```
+src/
+├── main.rs                      # Entry point
+├── lib.rs                       # Library root
+│
+├── utils/                       # Utilities
+│   ├── mod.rs
+│   ├── version.rs               # Version management (nebula/pulsar)
+│   └── tests.rs                 # Integration tests
+│
+├── frontend/                    # Source → AST
+│   ├── mod.rs
+│   ├── token.rs                 # Token definitions
+│   ├── ast.rs                   # AST definitions
+│   │
+│   ├── lexer/                   # Tokenization
+│   │   ├── mod.rs               # Main lexer logic
+│   │   └── reader.rs            # Character reading
+│   │
+│   └── parser/                  # Parsing
+│       ├── mod.rs               # Main parser logic
+│       ├── expr.rs              # Expression parsing
+│       └── stmt.rs              # Statement parsing
+│
+└── runtime/                     # AST → Execution
+    ├── mod.rs
+    ├── value.rs                 # Value types (String, Null)
+    │
+    ├── builtins/                # Built-in functions
+    │   ├── mod.rs               # Function router
+    │   └── log.rs               # log() implementation
+    │
+    └── interpreter/             # Execution
+        ├── mod.rs               # Main interpreter
+        ├── expr.rs              # Expression evaluator
+        └── stmt.rs              # Statement executor
+```
+
+## Module Responsibilities
+
+### Frontend
+- **token.rs**: Token enum definitions
+- **ast.rs**: AST node definitions (Expr, Stmt)
+- **lexer/**: Converts source text → tokens
+  - `reader.rs`: Character-level operations
+  - `mod.rs`: Tokenization logic
+- **parser/**: Converts tokens → AST
+  - `expr.rs`: Expression parsing
+  - `stmt.rs`: Statement parsing
+  - `mod.rs`: Main parser orchestration
+
+### Runtime
+- **value.rs**: Runtime value types
+- **builtins/**: Built-in functions (each function gets its own file)
+  - `log.rs`: The `log()` function
+  - `mod.rs`: Routes function calls
+- **interpreter/**: Executes AST
+  - `expr.rs`: Evaluates expressions
+  - `stmt.rs`: Executes statements
+  - `mod.rs`: Main interpreter orchestration
+
+### Utils
+- **version.rs**: Version string generation
+- **tests.rs**: Integration tests
+
+## Benefits of This Structure
+
+1. **Modularity**: Each component has a single responsibility
+2. **Extensibility**: Easy to add new builtins (just create a new file in `builtins/`)
+3. **Testability**: Each module can be tested independently
+4. **Clarity**: Clear separation between parsing and execution
+5. **Maintainability**: Small, focused files instead of monoliths
+
+## Adding New Features
+
+### Adding a new builtin function:
+1. Create `src/runtime/builtins/myfunction.rs`
+2. Implement the function following the pattern in `log.rs`
+3. Add it to `src/runtime/builtins/mod.rs`
+
+### Extending the lexer:
+- Add character handling to `src/frontend/lexer/reader.rs`
+- Add tokenization logic to `src/frontend/lexer/mod.rs`
+
+### Extending the parser:
+- Modify `src/frontend/parser/expr.rs` for expressions
+- Modify `src/frontend/parser/stmt.rs` for statements
+- Update `src/frontend/ast.rs` if new AST nodes are needed
+
+### Extending the interpreter:
+- Modify `src/runtime/interpreter/expr.rs` for expression evaluation
+- Modify `src/runtime/interpreter/stmt.rs` for statement execution
+- Update `src/runtime/value.rs` if new value types are needed

README.md

@@ -11,11 +11,13 @@ Noviq- The name Noviq is make up of two words: Nova(which means new) and unique.
 
 - So, Nova + unique = Noviq.
 
-**Noviq** = **Nova** (new) + **unique**- Noviq is just a simple compiled programming language writtin in Rust which aims to be independent in the future, i.e, being writtin in Noviq itself similar to how rust does it.
+**Noviq** = **Nova** (new) + **unique**- Noviq is just a simple interpreted programming language writtin in Rust which aims to be independent in the future, i.e, being writtin in Noviq itself similar to how rust does it.
 
-A simple, compiled programming language written in Rust with a focus on clarity and ease of use.
+A simple, interpreted programming language written in Rust with a focus on clarity and ease of use.
 A language written to have an easy syntax and high performance.
 
+Noviq aims to be a compiled language instead of an interpreted language in the future.
+
 ## Building
 
 ```bash

STRUCTURE.md

@@ -0,0 +1,218 @@
+# Noviq Project Structure
+
+This document describes the organization of the Noviq interpreter codebase.
+
+## Overview
+
+Noviq is an interpreted programming language written in Rust. The project is organized as a library (`lib.rs`) with a minimal binary entry point (`main.rs`).
+
+## Directory Structure
+
+```
+Noviq/
+├── src/
+│   ├── main.rs                  # Binary entry point
+│   ├── lib.rs                   # Library root
+│   ├── utils/                   # Utilities
+│   │   ├── mod.rs               # Utils module exports
+│   │   ├── version.rs           # Version management
+│   │   └── tests.rs             # Integration tests
+│   ├── frontend/                # Lexer and Parser
+│   │   ├── mod.rs               # Frontend module exports
+│   │   ├── token.rs             # Token definitions
+│   │   ├── ast.rs               # AST definitions
+│   │   ├── lexer/               # Tokenization
+│   │   │   ├── mod.rs           # Lexer main logic
+│   │   │   └── reader.rs        # Character reading utilities
+│   │   └── parser/              # AST generation
+│   │       ├── mod.rs           # Parser main logic
+│   │       ├── expr.rs          # Expression parsing
+│   │       └── stmt.rs          # Statement parsing
+│   └── runtime/                 # Interpreter and execution
+│       ├── mod.rs               # Runtime module exports
+│       ├── value.rs             # Runtime value types
+│       ├── builtins/            # Built-in functions
+│       │   ├── mod.rs           # Builtin router
+│       │   └── log.rs           # log() function
+│       └── interpreter/         # Execution engine
+│           ├── mod.rs           # Interpreter main logic
+│           ├── expr.rs          # Expression evaluation
+│           └── stmt.rs          # Statement execution
+├── examples/                    # Example Noviq programs
+│   ├── README.md
+│   ├── hello.nvq
+│   └── test.nvq
+├── Cargo.toml
+├── README.md
+├── STRUCTURE.md
+└── build.sh/bat/ps1
+```
+
+## Module Organization
+
+### `main.rs`
+The binary entry point. Kept minimal - only initializes and calls into the library.
+Handles command-line arguments:
+- No args: Shows version info and usage
+- `--help` / `-h`: Shows help message
+- `--version` / `-v`: Shows version
+- `<file.nvq>`: Reads and executes a Noviq file
+
+### `lib.rs`
+The library root that:
+- Declares all modules
+- Re-exports public API
+- Provides documentation for the crate
+
+### `utils/`
+Utility modules:
+- `version.rs` - Version string generation (nebula-X.Y.Z or pulsar builds)
+- `tests.rs` - Integration tests
+
+### `frontend/`
+Tokenization and parsing:
+- `token.rs` - Token type definitions
+- `ast.rs` - AST node definitions (Expr, Stmt)
+- `lexer/` - Tokenizer implementation
+  - `mod.rs` - Main lexer logic
+  - `reader.rs` - Character reading and string/identifier extraction
+- `parser/` - Parser implementation
+  - `mod.rs` - Main parser logic
+  - `expr.rs` - Expression parsing
+  - `stmt.rs` - Statement parsing
+
+### `runtime/`
+Execution and built-in functions:
+- `value.rs` - Runtime value types
+- `builtins/` - Built-in function implementations
+  - `mod.rs` - Builtin function router
+  - `log.rs` - The `log()` function
+- `interpreter/` - Execution engine
+  - `mod.rs` - Main interpreter logic
+  - `expr.rs` - Expression evaluator
+  - `stmt.rs` - Statement executor
+
+### `tests.rs`
+Integration tests that verify:
+- Example files exist and are readable
+- File syntax is correct
+- Core functionality works as expected
+
+### `examples/`
+Example Noviq programs (`.nvq` extension):
+- `hello.nvq` - Basic hello world with log statements
+- `test.nvq` - Simple log test
+- Each example demonstrates language features
+
+## Current Features
+
+The interpreter currently supports:
+- **Comments**: Lines starting with `#`
+- **String literals**: Double-quoted strings with escape sequences
+- **Function calls**: `log("message")` - prints to stdout
+
+## Module Organization
+
+### Frontend (Parsing)
+```
+frontend/
+├── token.rs           - Token enum (Identifier, String, LeftParen, etc.)
+├── ast.rs             - AST nodes (Expr, Stmt)
+├── lexer/
+│   ├── mod.rs         - Main tokenization logic
+│   └── reader.rs      - Character-level reading (skip whitespace, read strings, etc.)
+└── parser/
+    ├── mod.rs         - Main parsing logic
+    ├── expr.rs        - Expression parser
+    └── stmt.rs        - Statement parser
+```
+
+### Runtime (Execution)
+```
+runtime/
+├── value.rs           - Value enum (String, Null)
+├── builtins/
+│   ├── mod.rs         - Routes builtin calls by name
+│   └── log.rs         - log() implementation
+└── interpreter/
+    ├── mod.rs         - Main interpreter
+    ├── expr.rs        - Expression evaluator
+    └── stmt.rs        - Statement executor
+```
+
+### Utils
+```
+utils/
+├── version.rs         - Version string generation
+└── tests.rs           - Integration tests
+```
+
+## Building
+
+```bash
+# Debug build (includes pulsar timestamp)
+cargo build
+
+# Release build
+cargo build --release
+
+# Snapshot build (optimized but with pulsar timestamp)
+SNAPSHOT=1 cargo build --profile=snapshot
+```
+
+## Testing
+
+```bash
+# Run all tests
+cargo test
+
+# Run a specific test
+cargo test test_example_files_exist
+
+# Run tests with output
+cargo test -- --nocapture
+```
+
+## Running Examples
+
+```bash
+# Run with cargo
+cargo run -- examples/hello.nvq
+
+# Or run the binary directly
+./target/debug/noviq examples/hello.nvq
+
+# Show help
+./target/debug/noviq --help
+
+# Show version
+./target/debug/noviq --version
+```
+
+## Design Principles
+
+1. **Separation of Concerns**: Each module has a single, well-defined purpose
+2. **Library-First**: Core functionality in `lib.rs`, binary is just a thin wrapper
+3. **Testability**: Each module includes its own tests
+4. **Documentation**: All public items are documented
+5. **Extensibility**: Easy to add new modules without modifying existing code
+
+## Adding New Features
+
+To add a new feature:
+
+1. Create a new module file in the appropriate directory
+2. Add module declaration to `lib.rs` or the parent module
+3. Implement the feature with tests
+4. Update documentation
+5. Re-export public items if needed
+
+Example:
+```rust
+// src/builtins/math.rs
+pub fn add(a: i64, b: i64) -> i64 { a + b }
+
+// src/builtins/mod.rs
+pub mod math;
+pub use math::add;
+```

examples/README.md

@@ -0,0 +1,30 @@
+# Noviq Examples
+
+This directory contains example Noviq programs (`.nvq` files).
+
+## Running Examples
+
+```bash
+# Run an example file
+noviq examples/hello.nvq
+
+# Or with cargo
+cargo run -- examples/hello.nvq
+```
+
+## Available Examples
+
+### `hello.nvq`
+Basic hello world program demonstrating:
+- Print statements with `log()`
+- Comments with `#`
+- String literals
+
+### `test.nvq`
+Basic test file for development
+
+## Current Language Features
+
+- **Comments**: `# This is a comment`
+- **String literals**: `"Hello, World!"`
+- **Function calls**: `log("message")`

examples/hello.nvq

@@ -0,0 +1,6 @@
+# Hello World Example
+# This is a simple Noviq program
+
+log("Hello, World!")
+log("Welcome to Noviq!")
+log("This is a test of the log function")

examples/test.nvq

@@ -0,0 +1,5 @@
+# Basic test
+
+log("Testing")
+log("Multiple")
+log("Lines")