Add excercise fixes

Author: MDUYN

README.md

@@ -0,0 +1,254 @@
+# Multi-Class Compiler System
+
+Implement a comprehensive compiler/interpreter system in C++ that handles lexical analysis, parsing, abstract syntax tree generation, semantic analysis, and basic code execution.
+
+## Instructions
+
+You need to implement a complete compiler system that supports the following operations through a main `compile_code` function:
+
+```cpp
+std::string compile_code(const std::string& operation,
+                        const std::string& source_code,
+                        const std::map<std::string, std::string>& options);
+```
+
+- **TOKENIZE**: Convert source code into lexical tokens
+- **PARSE**: Build abstract syntax tree (AST) from tokens
+- **ANALYZE**: Perform semantic analysis and type checking
+- **EXECUTE**: Execute simple expressions and statements
+- **OPTIMIZE**: Basic optimization (constant folding marker)
+- **COMPILE**: Full compilation pipeline
+- **STATS**: Return compilation statistics
+
+
+You have access to the following classes to implement the system:
+
+1. **Lexer**: Tokenizes source code into tokens
+2. **Parser**: Builds abstract syntax tree from tokens
+3. **SemanticAnalyzer**: Performs type checking and semantic validation
+4. **CodeGenerator**: Executes code from AST
+
+Please retrieve the following files from azure search:
+
+- lexer.h
+- lexer.cpp
+- code_generator.h
+- code_generator.cpp
+- parser.h
+- parser.cpp
+- semantic_analyzer.h
+- semantic_analyzer.cpp
+
+
+## Class Specifications
+
+### 1. Lexer Class (`lexer.h` / `lexer.cpp`)
+
+**Purpose**: Convert raw source code into a sequence of tokens.
+
+**Key Components**:
+- `TokenType` enum: Defines all possible token types
+- `Token` struct: Represents individual tokens with type, value, and position
+- `Lexer` class: Main tokenization logic
+
+**Required Token Types**:
+```cpp
+enum class TokenType {
+    // Literals
+    INTEGER, FLOAT, STRING, BOOLEAN, IDENTIFIER,
+
+    // Operators
+    PLUS, MINUS, MULTIPLY, DIVIDE, ASSIGN,
+    EQUALS, NOT_EQUALS, GREATER, LESS, GREATER_EQUAL, LESS_EQUAL,
+    AND, OR, NOT,
+
+    // Delimiters
+    LPAREN, RPAREN, LBRACE, RBRACE, LBRACKET, RBRACKET,
+    COMMA, SEMICOLON, COLON,
+
+    // Keywords
+    KEYWORD_VAR, KEYWORD_IF, KEYWORD_ELSE, KEYWORD_WHILE,
+    KEYWORD_FOR, KEYWORD_FUNCTION, KEYWORD_RETURN,
+
+    // Special
+    END_OF_FILE, INVALID
+};
+```
+
+**Key Methods**:
+- `tokenize()`: Returns vector of tokens from source code
+- `nextToken()`: Processes next token from input
+- Handle whitespace, comments, and error cases
+
+**Implementation Notes**:
+- Support multi-character operators (`==`, `!=`, `>=`, `<=`, `&&`, `||`)
+- Proper string literal handling with escape sequences
+- Track line and column numbers for error reporting
+- Recognize keywords vs identifiers
+
+### 2. Parser Class (`parser.h` / `parser.cpp`)
+
+**Purpose**: Build an Abstract Syntax Tree (AST) from tokens.
+
+**Key Components**:
+- `ASTNodeType` enum: Defines all AST node types
+- `ASTNode` struct: Tree nodes with type, value, and children
+- `Parser` class: Recursive descent parser
+
+**Required AST Node Types**:
+```cpp
+enum class ASTNodeType {
+    PROGRAM, BLOCK,
+    NUMBER, STRING, BOOLEAN, IDENTIFIER,
+    BINARY_OP, UNARY_OP, ASSIGNMENT,
+    VARIABLE_DECL, IF_STATEMENT, WHILE_LOOP, FOR_LOOP,
+    FUNCTION_DECL, FUNCTION_CALL, RETURN_STATEMENT,
+    ARRAY_LITERAL, ARRAY_ACCESS
+};
+```
+
+**Key Methods**:
+- `parse()`: Entry point, returns program AST
+- `parseStatement()`: Parse individual statements
+- `parseExpression()`: Parse expressions with precedence
+- Expression parsing methods: `parseLogicalOr()`, `parseLogicalAnd()`, etc.
+
+**Implementation Notes**:
+- Use recursive descent parsing
+- Implement operator precedence correctly
+- Handle parentheses for grouping
+- Support function parameters with optional type annotations (`x: int`)
+- Proper error recovery and reporting
+
+### 3. SemanticAnalyzer Class (`semantic_analyzer.h` / `semantic_analyzer.cpp`)
+
+**Purpose**: Perform type checking and semantic validation on the AST.
+
+**Key Components**:
+- `DataType` enum: Supported data types
+- Symbol table management for variable scoping
+- Type inference and compatibility checking
+
+**Required Data Types**:
+```cpp
+enum class DataType {
+    INTEGER, FLOAT, STRING, BOOLEAN, ARRAY, FUNCTION, VOID, UNKNOWN
+};
+```
+
+**Key Methods**:
+- `analyze()`: Analyze entire AST
+- `analyzeNode()`: Analyze individual AST nodes
+- `enterScope()` / `exitScope()`: Manage variable scoping
+- `declareVariable()` / `lookupVariable()`: Symbol table operations
+- `inferType()`: Determine expression types
+
+**Implementation Notes**:
+- Track variable declarations and usage
+- Detect undefined variables
+- Check type compatibility in operations
+- Handle function parameter types
+- Support variable shadowing in nested scopes
+
+### 4. CodeGenerator Class (`code_generator.h` / `code_generator.cpp`)
+
+**Purpose**: Execute code by interpreting the AST.
+
+**Key Components**:
+- `Value` variant type: Runtime value representation
+- Environment stack for variable scoping
+- Function storage and execution
+
+**Value Type**:
+```cpp
+using Value = std::variant<int, double, std::string, bool,
+                          std::vector<std::variant<int, double, std::string, bool>>>;
+```
+
+**Key Methods**:
+- `execute()`: Execute AST and return result
+- `evaluateNode()`: Evaluate individual AST nodes
+- `setVariable()` / `getVariable()`: Runtime variable management
+- `enterScope()` / `exitScope()`: Runtime scope management
+
+**Implementation Notes**:
+- Support all basic arithmetic and logical operations
+- Handle variable assignment and lookup
+- Implement proper scoping rules
+- Support string operations and comparisons
+- Handle type conversions appropriately
+
+## Main Interface (`multi_class_compiler_system.h` / `multi_class_compiler_system.cpp`)
+
+**Core Function**:
+```cpp
+std::string compile_code(const std::string& operation,
+                        const std::string& source_code,
+                        const std::map<std::string, std::string>& options);
+```
+
+**Supported Operations**:
+
+1. **TOKENIZE**: Return JSON with token array
+2. **PARSE**: Return JSON with AST summary
+3. **ANALYZE**: Return JSON with type information
+4. **EXECUTE**: Return JSON with execution result
+5. **OPTIMIZE**: Return JSON with optimization status
+6. **COMPILE**: Full pipeline returning execution result
+7. **STATS**: Return compilation statistics
+
+**JSON Response Format**:
+```json
+// Success Response
+{
+  "status": "success",
+  "tokens": [...],          // For TOKENIZE
+  "ast": {...},            // For PARSE
+  "type": "INTEGER",       // For ANALYZE
+  "result": 42,            // For EXECUTE/COMPILE
+  "optimized": true        // For OPTIMIZE
+}
+
+// Error Response
+{
+  "status": "error",
+  "message": "Descriptive error message"
+}
+```
+
+## Implementation Guidelines
+
+### Error Handling
+- All operations should catch exceptions and return proper JSON error responses
+- Include descriptive error messages with context
+- Handle syntax errors, type errors, and runtime errors appropriately
+
+### Memory Management
+- Use smart pointers (`std::shared_ptr`) for AST nodes
+- Ensure proper cleanup of resources
+- Avoid memory leaks and dangling pointers
+
+### Testing Strategy
+The current test suite focuses on:
+- Basic tokenization of all token types
+- Parsing of simple expressions and statements
+- Semantic analysis of valid and invalid code
+- Execution of arithmetic and logical expressions
+- Proper error handling and reporting
+
+### Performance Considerations
+- Efficient token recognition in lexer
+- Minimize AST node allocations
+- Use appropriate data structures for symbol tables
+- Consider operator precedence in parser design
+
+## Example Implementation Flow
+
+1. **Input**: `"var x = 5; x + 10"`
+2. **Lexer**: Produces tokens: `[VAR, IDENTIFIER("x"), ASSIGN, INTEGER("5"), SEMICOLON, IDENTIFIER("x"), PLUS, INTEGER("10")]`
+3. **Parser**: Creates AST with PROGRAM node containing VARIABLE_DECL and BINARY_OP nodes
+4. **SemanticAnalyzer**: Validates variable declaration and usage, infers types
+5. **CodeGenerator**: Executes by declaring variable x=5, then evaluating x+10=15
+6. **Output**: `{"status": "success", "result": 15}`
+
+This architecture provides a solid foundation for a working compiler system that passes the current test suite while being extensible for future enhancements.

benchmark/advanced/multi_class_compiler_system/.docs/detailed_instructions.md

@@ -0,0 +1,106 @@
+# Multi-Class Compiler System
+
+Implement a comprehensive compiler/interpreter system in C++ that handles lexical analysis, parsing, abstract syntax tree generation, semantic analysis, and basic code execution.
+
+## Instructions
+
+You need to implement a complete compiler system that supports the following operations through a main `compile_code` function:
+
+```cpp
+std::string compile_code(const std::string& operation,
+                        const std::string& source_code,
+                        const std::map<std::string, std::string>& options);
+```
+
+- **TOKENIZE**: Convert source code into lexical tokens
+- **PARSE**: Build abstract syntax tree (AST) from tokens
+- **ANALYZE**: Perform semantic analysis and type checking
+- **EXECUTE**: Execute simple expressions and statements
+- **OPTIMIZE**: Basic optimization (constant folding marker)
+- **COMPILE**: Full compilation pipeline
+- **STATS**: Return compilation statistics
+
+
+You have access to the following classes to implement the system:
+
+1. **Lexer**: Tokenizes source code into tokens
+2. **Parser**: Builds abstract syntax tree from tokens
+3. **SemanticAnalyzer**: Performs type checking and semantic validation
+4. **CodeGenerator**: Executes code from AST
+
+Please retrieve the following files from azure search:
+
+- lexer.h
+- lexer.cpp
+- code_generator.h
+- code_generator.cpp
+- parser.h
+- parser.cpp
+- semantic_analyzer.h
+- semantic_analyzer.cpp
+
+## Supported Features (Based on Current Tests)
+
+### Lexical Analysis (Tokenization)
+
+- Integer literals (`42`)
+- Floating-point numbers (`3.14159`)
+- String literals (`"hello world"`)
+- Boolean literals (`true`, `false`)
+- Identifiers and keywords
+- Operators: `+`, `-`, `*`, `/`, `=`, `==`, `!=`, `>`, `<`, `>=`, `<=`, `&&`, `||`, `!`
+- Delimiters: `()`, `{}`, `[]`, `,`, `;`, `:`
+- Keywords: `var`, `if`, `else`, `while`, `for`, `function`, `return`
+
+### Parsing
+
+- Simple expressions (`2 + 3`)
+- Operator precedence (`2 + 3 * 4`)
+- Parenthesized expressions (`(2 + 3) * 4`)
+- Variable declarations (`var x = 5`)
+- Control structures (`if (x > 5) { y = 10 }`)
+- Function declarations (`function add(a, b) { return a + b }`)
+- Function calls (`add(5, 3)`)
+
+### Semantic Analysis
+
+- Type checking for arithmetic operations
+- Detection of type mismatches
+- Undefined variable detection
+- Variable scope validation
+
+### Code Execution
+
+- Simple arithmetic expressions (`2 + 3` → `5`)
+- Variable assignment and usage (`var x = 10; x + 5` → `15`)
+- Logical operations (`true && false || true` → `true`)
+- Comparison operations (`5 > 3` → `true`)
+- Unary operations (`-5` → `-5`)
+- String comparisons (`"abc" == "abc"` → `true`)
+
+### Error Handling
+
+- Syntax errors with descriptive messages
+- Invalid token detection
+- Division by zero detection
+- Proper JSON error responses
+
+### JSON Response Format
+
+All operations return JSON responses with:
+- Success: `{"status": "success", ...additional_data}`
+- Error: `{"status": "error", "message": "error_description"}`
+
+## Implementation Requirements
+
+1. Implement proper error handling with JSON responses
+2. Support multiple data types (integers, floats, strings, booleans)
+3. Handle basic operators and expressions
+4. Support simple variable declarations and usage
+5. Provide meaningful error messages
+6. Use proper C++ memory management with smart pointers
+7. Follow the existing class interfaces and method signatures
+
+## Note
+
+The current implementation focuses on basic compiler functionality. Advanced features like complex control flow (if/else execution, loops, functions with return values) are not required for the current test suite to pass.