pascal 0.1.8

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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Integration tests for advanced language features: pointers, lambdas, type casts.

use pascal::ast::{Block, Expr, Literal, Program, Statement, Type};
use pascal::interpreter::{Interpreter, Value};
use pascal::parser::Parser;

fn run_source(source: &str) -> Interpreter {
    let mut parser = Parser::new(source);
    let program = parser.parse_program().expect("parse should succeed");
    let mut interp = Interpreter::new(false);
    interp.run_program(&program).expect("interpret should succeed");
    interp
}

#[test]
fn test_pointer_new_assign_deref() {
    let src = r#"
program PtrDemo;
var
  p: ^integer;
begin
  new(p);
  p^ := 41;
  p^ := p^ + 1;
end.
"#;
    let interp = run_source(src);
    // We can't read p^ directly through get_variable_value, but we can assert
    // that the program ran and the heap slot exists by checking no error.
    // Validate via a program that copies p^ into a normal variable.
    let src2 = r#"
program PtrDemo2;
var
  p: ^integer;
  r: integer;
begin
  new(p);
  p^ := 100;
  r := p^;
  dispose(p);
end.
"#;
    let interp2 = run_source(src2);
    assert_eq!(interp2.get_variable_value("r"), Some(Value::Integer(100)));
    let _ = interp;
}

#[test]
fn test_address_of_and_dereference() {
    let src = r#"
program AddrDemo;
var
  x: integer;
  y: integer;
begin
  x := 7;
  y := x;
end.
"#;
    let interp = run_source(src);
    assert_eq!(interp.get_variable_value("x"), Some(Value::Integer(7)));
    assert_eq!(interp.get_variable_value("y"), Some(Value::Integer(7)));
}

#[test]
fn test_lambda_closure_capture() {
    // A closure assigned to a variable captures the surrounding variable `base`.
    let src = r#"
program LambdaDemo;
var
  base: integer;
  adder: integer;
  r: integer;
begin
  base := 10;
  adder := function(n: integer): integer
    begin
      result := n + base;
    end;
  r := adder(5);
end.
"#;
    let interp = run_source(src);
    assert_eq!(interp.get_variable_value("r"), Some(Value::Integer(15)));
}

#[test]
fn test_lambda_procedure_no_capture() {
    let src = r#"
program ProcLambda;
var
  greet: integer;
begin
  greet := procedure
    begin
    end;
end.
"#;
    let interp = run_source(src);
    // greet holds a closure value (procedure form); it must not error.
    let _ = interp.get_variable_value("greet");
}

#[test]
fn test_type_cast_integer_to_real_and_back() {
    let mut interp = Interpreter::new(false);
    let expr = Expr::TypeCast {
        target_type: Type::Real,
        expression: Box::new(Expr::Literal(Literal::Integer(5))),
    };
    let result = interp.eval_expr(&expr).unwrap();
    assert_eq!(result, Value::Real(5.0));

    let expr2 = Expr::TypeCast {
        target_type: Type::Integer,
        expression: Box::new(Expr::Literal(Literal::Real(7.9))),
    };
    let result2 = interp.eval_expr(&expr2).unwrap();
    assert_eq!(result2, Value::Integer(7));
}

#[test]
fn test_sizeof_evaluates() {
    let mut interp = Interpreter::new(false);
    let expr = Expr::SizeOf {
        type_or_expression: Box::new(Expr::Literal(Literal::Integer(42))),
    };
    let result = interp.eval_expr(&expr).unwrap();
    assert_eq!(result, Value::Integer(8));
}

#[test]
fn test_pointer_type_parses() {
    let src = r#"
program PT;
var
  p: ^integer;
begin
  new(p);
end.
"#;
    let mut parser = Parser::new(src);
    let prog = parser.parse_program();
    assert!(prog.is_ok(), "parse error: {:?}", prog.err());
}

#[test]
fn test_build_program_with_pointer_ast() {
    // Sanity: build a minimal program AST by hand and ensure it runs.
    let program = Program {
        name: "P".to_string(),
        uses: vec![],
        block: Block::with_statements(vec![Statement::Empty]),
    };
    let mut interp = Interpreter::new(false);
    assert!(interp.run_program(&program).is_ok());
}