pascal 0.1.4

A modern Pascal compiler with build/intepreter/package manager built with Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! Example: Using parallel compilation via MCP Server
//! 
//! This example demonstrates how to use the MCP server interface
//! for parallel compilation of Pascal modules.

use pascal::{McpServer, McpServerBuilder, CompileRequest, StatusRequest};

fn main() {
    println!("=== Pascal Compiler - MCP Server Examples ===\n");

    // Example 1: Create MCP server with default configuration
    println!("1. Creating MCP server with default configuration:");
    let server = McpServerBuilder::new().build();
    
    let status = server.handle_status(StatusRequest {});
    println!("   Version: {}", status.version);
    println!("   Parallel enabled: {}", status.parallel_enabled);
    println!("   Threads: {}", status.threads);
    println!("   Cached modules: {}", status.cached_modules.len());
    println!();

    // Example 2: Create MCP server with custom configuration
    println!("2. Creating MCP server with custom configuration:");
    let mut server = McpServerBuilder::new()
        .threads(4)
        .parallel_modules(true)
        .parallel_optimization(true)
        .build();
    println!("   Server created with 4 threads");
    println!();

    // Example 3: Compile single module (sequential)
    println!("3. Compiling single module (sequential):");
    let request = CompileRequest {
        modules: vec!["System".to_string()],
        parallel: false,
        threads: 1,
        search_paths: vec!["./stdlib".to_string()],
    };
    
    let response = server.handle_compile(request);
    println!("   Success: {}", response.success);
    println!("   Compiled: {:?}", response.compiled);
    println!("   Errors: {}", response.errors.len());
    println!("   Duration: {}ms", response.duration_ms);
    println!();

    // Example 4: Compile multiple modules in parallel
    println!("4. Compiling multiple modules in parallel:");
    let request = CompileRequest {
        modules: vec![
            "System".to_string(),
            "SysUtils".to_string(),
            "Classes".to_string(),
            "Math".to_string(),
        ],
        parallel: true,
        threads: 4,
        search_paths: vec!["./stdlib".to_string()],
    };
    
    let response = server.handle_compile(request);
    println!("   Success: {}", response.success);
    println!("   Compiled: {} modules", response.compiled.len());
    println!("   Errors: {}", response.errors.len());
    println!("   Duration: {}ms", response.duration_ms);
    
    for error in &response.errors {
        println!("   Error in {}: {}", error.module, error.message);
    }
    println!();

    // Example 5: Check cached modules
    println!("5. Checking cached modules:");
    let cached = server.get_cached_modules();
    println!("   Cached modules: {}", cached.len());
    for module in &cached {
        println!("     - {}", module);
    }
    println!();

    // Example 6: Clear cache
    println!("6. Clearing module cache:");
    server.clear_cache();
    let cached = server.get_cached_modules();
    println!("   Cached modules after clear: {}", cached.len());
    println!();

    // Example 7: Large batch compilation
    println!("7. Large batch compilation (parallel):");
    let modules: Vec<String> = (1..=20)
        .map(|i| format!("Module{}", i))
        .collect();
    
    let request = CompileRequest {
        modules,
        parallel: true,
        threads: 8,
        search_paths: vec!["./lib".to_string()],
    };
    
    let response = server.handle_compile(request);
    println!("   Compiled: {} modules", response.compiled.len());
    println!("   Errors: {}", response.errors.len());
    println!("   Duration: {}ms", response.duration_ms);
    println!("   Throughput: {:.2} modules/sec", 
        20.0 / (response.duration_ms as f64 / 1000.0));
    println!();

    println!("=== MCP Server Examples Complete ===");
}