ned 15 mar 2026 14:15:12 CET e


b.p26

fun f() : {} = 
    ^a^
 A9: Nodes<Defn> 
1:1-3:0
 A8: DefFunDefn f 
1:1-2:7
 A5: Nodes<ParDefn> 
 A1: UniType 
1:11-1:12
 A0: Nodes<CompDefn> 
 A7: Exprs 
2:5-2:7
 A6: Nodes<Expr> 
2:5-2:7
 A4: PfxExpr PTR 
2:5-2:7
 A3: SfxExpr PTR 
2:6-2:7
 A2: NameExpr a 
2:6-2:6

fak.p26

typ hax = {a : int}
var id : (((((((int)))))))
fun x() : void =
	(1, 2, 3, 4)
 A18: Nodes<Defn> 
1:1-5:0
 A4: TypDefn hax 
1:1-1:19
 A3: UniType 
1:11-1:19
 A2: Nodes<CompDefn> 
1:11-1:19
 A1: CompDefn a 
1:12-1:18
 A0: AtomType INT 
1:16-1:18
 A6: VarDefn id 
2:1-2:26
 A5: AtomType INT 
2:10-2:26
 A17: DefFunDefn x 
3:1-4:20
 A14: Nodes<ParDefn> 
 A7: AtomType VOID 
3:11-3:14
 A16: Exprs 
4:9-4:20
 A15: Nodes<Expr> 
4:9-4:20
 A13: Exprs 
4:9-4:20
 A12: Nodes<Expr> 
4:9-4:20
 A8: AtomExpr 1 
4:10-4:10
 A9: AtomExpr 2 
4:13-4:13
 A10: AtomExpr 3 
4:16-4:16
 A11: AtomExpr 4 
4:19-4:19

prog1.p26

fun a(b: int): int =

    b * if b then b + 1 end
 A16: Nodes<Defn> 
1:1-4:0
 A15: DefFunDefn a 
1:1-3:27
 A12: Nodes<ParDefn> 
1:6-1:13
 A1: ParDefn b 
1:7-1:12
 A0: AtomType INT 
1:10-1:12
 A2: AtomType INT 
1:16-1:18
 A14: Exprs 
3:5-3:27
 A13: Nodes<Expr> 
3:5-3:27
 A11: BinExpr MUL 
3:5-3:27
 A3: NameExpr b 
3:5-3:5
 A10: IfThenExpr 
3:9-3:27
 A4: NameExpr b 
3:12-3:12
 A9: Exprs 
3:19-3:23
 A8: Nodes<Expr> 
3:19-3:23
 A7: BinExpr ADD 
3:19-3:23
 A5: NameExpr b 
3:19-3:19
 A6: AtomExpr 1 
3:23-3:23

prog2.p26

fun a(b: int): int =

    b * while b do b + 1 end
 A16: Nodes<Defn> 
1:1-4:0
 A15: DefFunDefn a 
1:1-3:28
 A12: Nodes<ParDefn> 
1:6-1:13
 A1: ParDefn b 
1:7-1:12
 A0: AtomType INT 
1:10-1:12
 A2: AtomType INT 
1:16-1:18
 A14: Exprs 
3:5-3:28
 A13: Nodes<Expr> 
3:5-3:28
 A11: BinExpr MUL 
3:5-3:28
 A3: NameExpr b 
3:5-3:5
 A10: WhileExpr 
3:9-3:28
 A4: NameExpr b 
3:15-3:15
 A9: Exprs 
3:20-3:24
 A8: Nodes<Expr> 
3:20-3:24
 A7: BinExpr ADD 
3:20-3:24
 A5: NameExpr b 
3:20-3:20
 A6: AtomExpr 1 
3:24-3:24

synan.p26

typ stevilka = int
var globalnast : stevilka
fun funkcija (prviarg : stevilka, drugiarg : bool) : int =
	nvoaspr = a + -b - c,
	nvoaspr = nvoaspr * 3 + 2,
	nvoaspr = nvoaspr + 3 * 2,
	nvoaspr = 1 - 3 + 2,
	nvoaspr = 1 / 3 * 2 + 1 * 3 / 2,
	if 1 == 2 then 666 end
 A62: Nodes<Defn> 
1:1-10:0
 A1: TypDefn stevilka 
1:1-1:18
 A0: AtomType INT 
1:16-1:18
 A3: VarDefn globalnast 
2:1-2:25
 A2: NameType stevilka 
2:18-2:25
 A61: DefFunDefn funkcija 
3:1-9:30
 A58: Nodes<ParDefn> 
3:14-3:50
 A5: ParDefn prviarg 
3:15-3:32
 A4: NameType stevilka 
3:25-3:32
 A7: ParDefn drugiarg 
3:35-3:49
 A6: AtomType BOOL 
3:46-3:49
 A8: AtomType INT 
3:54-3:56
 A60: Exprs 
4:9-9:30
 A59: Nodes<Expr> 
4:9-9:30
 A16: AsgnExpr 
4:9-4:28
 A9: NameExpr nvoaspr 
4:9-4:15
 A15: BinExpr SUB 
4:19-4:28
 A13: BinExpr ADD 
4:19-4:24
 A10: NameExpr a 
4:19-4:19
 A12: PfxExpr SUB 
4:23-4:24
 A11: NameExpr b 
4:24-4:24
 A14: NameExpr c 
4:28-4:28
 A23: AsgnExpr 
5:9-5:33
 A17: NameExpr nvoaspr 
5:9-5:15
 A22: BinExpr ADD 
5:19-5:33
 A20: BinExpr MUL 
5:19-5:29
 A18: NameExpr nvoaspr 
5:19-5:25
 A19: AtomExpr 3 
5:29-5:29
 A21: AtomExpr 2 
5:33-5:33
 A30: AsgnExpr 
6:9-6:33
 A24: NameExpr nvoaspr 
6:9-6:15
 A29: BinExpr ADD 
6:19-6:33
 A25: NameExpr nvoaspr 
6:19-6:25
 A28: BinExpr MUL 
6:29-6:33
 A26: AtomExpr 3 
6:29-6:29
 A27: AtomExpr 2 
6:33-6:33
 A37: AsgnExpr 
7:9-7:27
 A31: NameExpr nvoaspr 
7:9-7:15
 A36: BinExpr ADD 
7:19-7:27
 A34: BinExpr SUB 
7:19-7:23
 A32: AtomExpr 1 
7:19-7:19
 A33: AtomExpr 3 
7:23-7:23
 A35: AtomExpr 2 
7:27-7:27
 A50: AsgnExpr 
8:9-8:39
 A38: NameExpr nvoaspr 
8:9-8:15
 A49: BinExpr ADD 
8:19-8:39
 A43: BinExpr MUL 
8:19-8:27
 A41: BinExpr DIV 
8:19-8:23
 A39: AtomExpr 1 
8:19-8:19
 A40: AtomExpr 3 
8:23-8:23
 A42: AtomExpr 2 
8:27-8:27
 A48: BinExpr DIV 
8:31-8:39
 A46: BinExpr MUL 
8:31-8:35
 A44: AtomExpr 1 
8:31-8:31
 A45: AtomExpr 3 
8:35-8:35
 A47: AtomExpr 2 
8:39-8:39
 A57: IfThenExpr 
9:9-9:30
 A53: BinExpr EQU 
9:12-9:17
 A51: AtomExpr 1 
9:12-9:12
 A52: AtomExpr 2 
9:17-9:17
 A56: Exprs 
9:24-9:26
 A55: Nodes<Expr> 
9:24-9:26
 A54: AtomExpr 666 
9:24-9:26

test10.p26

typ id = T

var id : T

fun id (par1 : { a: {}, b: (:{a: ( g : int)}:bool)}) : {}

fun id () : void = not true, +100, -100, 1+2, 1-3, 1*3, 4*22, 5/2, 35%23, true and false, false or true, assignme = 1,  a == b, 234 >= 123, 23<235, 34>2 , 3<5, 2<=2
 A81: Nodes<Defn> 
1:1-7:164
 A1: TypDefn id 
1:1-1:10
 A0: NameType T 
1:10-1:10
 A3: VarDefn id 
3:1-3:10
 A2: NameType T 
3:10-3:10
 A24: ExtFunDefn id 
5:1-5:57
 A23: Nodes<ParDefn> 
5:8-5:52
 A20: ParDefn par1 
5:9-5:51
 A19: UniType 
5:16-5:51
 A18: Nodes<CompDefn> 
5:16-5:51
 A6: CompDefn a 
5:18-5:22
 A5: UniType 
5:21-5:22
 A4: Nodes<CompDefn> 
 A17: CompDefn b 
5:25-5:50
 A16: FunType 
5:28-5:50
 A15: Nodes<Type> 
5:30-5:44
 A13: UniType 
5:30-5:44
 A12: Nodes<CompDefn> 
5:30-5:44
 A11: CompDefn a 
5:31-5:43
 A10: StrType 
5:34-5:43
 A9: Nodes<CompDefn> 
5:36-5:42
 A8: CompDefn g 
5:36-5:42
 A7: AtomType INT 
5:40-5:42
 A14: AtomType BOOL 
5:46-5:49
 A22: UniType 
5:56-5:57
 A21: Nodes<CompDefn> 
 A80: DefFunDefn id 
7:1-7:164
 A77: Nodes<ParDefn> 
 A25: AtomType VOID 
7:13-7:16
 A79: Exprs 
7:20-7:164
 A78: Nodes<Expr> 
7:20-7:164
 A27: PfxExpr NOT 
7:20-7:27
 A26: AtomExpr true 
7:24-7:27
 A29: PfxExpr ADD 
7:30-7:33
 A28: AtomExpr 100 
7:31-7:33
 A31: PfxExpr SUB 
7:36-7:39
 A30: AtomExpr 100 
7:37-7:39
 A34: BinExpr ADD 
7:42-7:44
 A32: AtomExpr 1 
7:42-7:42
 A33: AtomExpr 2 
7:44-7:44
 A37: BinExpr SUB 
7:47-7:49
 A35: AtomExpr 1 
7:47-7:47
 A36: AtomExpr 3 
7:49-7:49
 A40: BinExpr MUL 
7:52-7:54
 A38: AtomExpr 1 
7:52-7:52
 A39: AtomExpr 3 
7:54-7:54
 A43: BinExpr MUL 
7:57-7:60
 A41: AtomExpr 4 
7:57-7:57
 A42: AtomExpr 22 
7:59-7:60
 A46: BinExpr DIV 
7:63-7:65
 A44: AtomExpr 5 
7:63-7:63
 A45: AtomExpr 2 
7:65-7:65
 A49: BinExpr MOD 
7:68-7:72
 A47: AtomExpr 35 
7:68-7:69
 A48: AtomExpr 23 
7:71-7:72
 A52: BinExpr AND 
7:75-7:88
 A50: AtomExpr true 
7:75-7:78
 A51: AtomExpr false 
7:84-7:88
 A55: BinExpr OR 
7:91-7:103
 A53: AtomExpr false 
7:91-7:95
 A54: AtomExpr true 
7:100-7:103
 A58: AsgnExpr 
7:106-7:117
 A56: NameExpr assignme 
7:106-7:113
 A57: AtomExpr 1 
7:117-7:117
 A61: BinExpr EQU 
7:121-7:126
 A59: NameExpr a 
7:121-7:121
 A60: NameExpr b 
7:126-7:126
 A64: BinExpr GEQ 
7:129-7:138
 A62: AtomExpr 234 
7:129-7:131
 A63: AtomExpr 123 
7:136-7:138
 A67: BinExpr LTH 
7:141-7:146
 A65: AtomExpr 23 
7:141-7:142
 A66: AtomExpr 235 
7:144-7:146
 A70: BinExpr GTH 
7:149-7:152
 A68: AtomExpr 34 
7:149-7:150
 A69: AtomExpr 2 
7:152-7:152
 A73: BinExpr LTH 
7:156-7:158
 A71: AtomExpr 3 
7:156-7:156
 A72: AtomExpr 5 
7:158-7:158
 A76: BinExpr LEQ 
7:161-7:164
 A74: AtomExpr 2 
7:161-7:161
 A75: AtomExpr 2 
7:164-7:164

test11.p26

fun funny() : void = ^a[b].c^ as { a: {}, b: (:{a: ( g : int)}:bool)}, sizeof { a: {}, b: (:{a: ( g : int)}:bool)}


typ t = (::t)
 A49: Nodes<Defn> 
1:1-5:0
 A44: DefFunDefn funny 
1:1-1:114
 A41: Nodes<ParDefn> 
 A0: AtomType VOID 
1:15-1:18
 A43: Exprs 
1:22-1:114
 A42: Nodes<Expr> 
1:22-1:114
 A23: CastExpr 
1:22-1:69
 A6: PfxExpr PTR 
1:22-1:29
 A5: SfxExpr PTR 
1:23-1:29
 A4: CompExpr c 
1:23-1:28
 A3: ArrExpr 
1:23-1:26
 A1: NameExpr a 
1:23-1:23
 A2: NameExpr b 
1:25-1:25
 A22: UniType 
1:34-1:69
 A21: Nodes<CompDefn> 
1:34-1:69
 A9: CompDefn a 
1:36-1:40
 A8: UniType 
1:39-1:40
 A7: Nodes<CompDefn> 
 A20: CompDefn b 
1:43-1:68
 A19: FunType 
1:46-1:68
 A18: Nodes<Type> 
1:48-1:62
 A16: UniType 
1:48-1:62
 A15: Nodes<CompDefn> 
1:48-1:62
 A14: CompDefn a 
1:49-1:61
 A13: StrType 
1:52-1:61
 A12: Nodes<CompDefn> 
1:54-1:60
 A11: CompDefn g 
1:54-1:60
 A10: AtomType INT 
1:58-1:60
 A17: AtomType BOOL 
1:64-1:67
 A40: SizeExpr 
1:72-1:114
 A39: UniType 
1:79-1:114
 A38: Nodes<CompDefn> 
1:79-1:114
 A26: CompDefn a 
1:81-1:85
 A25: UniType 
1:84-1:85
 A24: Nodes<CompDefn> 
 A37: CompDefn b 
1:88-1:113
 A36: FunType 
1:91-1:113
 A35: Nodes<Type> 
1:93-1:107
 A33: UniType 
1:93-1:107
 A32: Nodes<CompDefn> 
1:93-1:107
 A31: CompDefn a 
1:94-1:106
 A30: StrType 
1:97-1:106
 A29: Nodes<CompDefn> 
1:99-1:105
 A28: CompDefn g 
1:99-1:105
 A27: AtomType INT 
1:103-1:105
 A34: AtomType BOOL 
1:109-1:112
 A48: TypDefn t 
4:1-4:13
 A47: FunType 
4:9-4:13
 A46: Nodes<Type> 
 LOCATION 
 A45: NameType t 
4:12-4:12

test12.p26

fun f() : void = let fun f():void in let fun f():void in (a, b, c) end, let fun f():int = 5+5 in sizeof [10]int end end
 A39: Nodes<Defn> 
1:1-1:119
 A38: DefFunDefn f 
1:1-1:119
 A35: Nodes<ParDefn> 
 A0: AtomType VOID 
1:11-1:14
 A37: Exprs 
1:18-1:119
 A36: Nodes<Expr> 
1:18-1:119
 A34: LetExpr 
1:18-1:119
 A31: Nodes<Defn> 
1:22-1:33
 A3: ExtFunDefn f 
1:22-1:33
 A2: Nodes<ParDefn> 
 A1: AtomType VOID 
1:30-1:33
 A33: Exprs 
1:38-1:115
 A32: Nodes<Expr> 
1:38-1:115
 A15: LetExpr 
1:38-1:70
 A12: Nodes<Defn> 
1:42-1:53
 A6: ExtFunDefn f 
1:42-1:53
 A5: Nodes<ParDefn> 
 A4: AtomType VOID 
1:50-1:53
 A14: Exprs 
1:58-1:66
 A13: Nodes<Expr> 
1:58-1:66
 A11: Exprs 
1:58-1:66
 A10: Nodes<Expr> 
1:58-1:66
 A7: NameExpr a 
1:59-1:59
 A8: NameExpr b 
1:62-1:62
 A9: NameExpr c 
1:65-1:65
 A30: LetExpr 
1:73-1:115
 A27: Nodes<Defn> 
1:77-1:93
 A23: DefFunDefn f 
1:77-1:93
 A20: Nodes<ParDefn> 
 A16: AtomType INT 
1:85-1:87
 A22: Exprs 
1:91-1:93
 A21: Nodes<Expr> 
1:91-1:93
 A19: BinExpr ADD 
1:91-1:93
 A17: AtomExpr 5 
1:91-1:91
 A18: AtomExpr 5 
1:93-1:93
 A29: Exprs 
1:98-1:111
 A28: Nodes<Expr> 
1:98-1:111
 A26: SizeExpr 
1:98-1:111
 A25: ArrType ArrType[10] 
1:105-1:111
 A24: AtomType INT 
1:109-1:111

test13.p26

fun a():ab = if if E4 then E5, E6 else E7, E8 end then while E9 do E10, "QWERHBEQR ", (if E4 then E5, E6 else E7, E8 end), E3 end end
 A37: Nodes<Defn> 
1:1-2:0
 A36: DefFunDefn a 
1:1-1:133
 A33: Nodes<ParDefn> 
 A0: NameType ab 
1:9-1:10
 A35: Exprs 
1:14-1:133
 A34: Nodes<Expr> 
1:14-1:133
 A32: IfThenExpr 
1:14-1:133
 A10: IfThenElseExpr 
1:17-1:49
 A1: NameExpr E4 
1:20-1:21
 A7: Exprs 
1:28-1:33
 A6: Nodes<Expr> 
1:28-1:33
 A2: NameExpr E5 
1:28-1:29
 A3: NameExpr E6 
1:32-1:33
 A9: Exprs 
1:40-1:45
 A8: Nodes<Expr> 
1:40-1:45
 A4: NameExpr E7 
1:40-1:41
 A5: NameExpr E8 
1:44-1:45
 A31: Exprs 
1:56-1:129
 A30: Nodes<Expr> 
1:56-1:129
 A29: WhileExpr 
1:56-1:129
 A11: NameExpr E9 
1:62-1:63
 A28: Exprs 
1:68-1:125
 A27: Nodes<Expr> 
1:68-1:125
 A12: NameExpr E10 
1:68-1:70
 A13: AtomExpr "QWERHBEQR " 
1:73-1:84
 A25: Exprs 
1:87-1:121
 A24: Nodes<Expr> 
1:87-1:121
 A23: IfThenElseExpr 
1:88-1:120
 A14: NameExpr E4 
1:91-1:92
 A20: Exprs 
1:99-1:104
 A19: Nodes<Expr> 
1:99-1:104
 A15: NameExpr E5 
1:99-1:100
 A16: NameExpr E6 
1:103-1:104
 A22: Exprs 
1:111-1:116
 A21: Nodes<Expr> 
1:111-1:116
 A17: NameExpr E7 
1:111-1:112
 A18: NameExpr E8 
1:115-1:116
 A26: NameExpr E3 
1:124-1:125

test14.p26

fun f() : bool = not a+b*b+a-c % 10 as int
 A19: Nodes<Defn> 
1:1-1:42
 A18: DefFunDefn f 
1:1-1:42
 A15: Nodes<ParDefn> 
 A0: AtomType BOOL 
1:11-1:14
 A17: Exprs 
1:18-1:42
 A16: Nodes<Expr> 
1:18-1:42
 A14: CastExpr 
1:18-1:42
 A12: BinExpr SUB 
1:18-1:35
 A8: BinExpr ADD 
1:18-1:28
 A6: BinExpr ADD 
1:18-1:26
 A2: PfxExpr NOT 
1:18-1:22
 A1: NameExpr a 
1:22-1:22
 A5: BinExpr MUL 
1:24-1:26
 A3: NameExpr b 
1:24-1:24
 A4: NameExpr b 
1:26-1:26
 A7: NameExpr a 
1:28-1:28
 A11: BinExpr MOD 
1:30-1:35
 A9: NameExpr c 
1:30-1:30
 A10: AtomExpr 10 
1:34-1:35
 A13: AtomType INT 
1:40-1:42

test15.p26

fun f() : void = a = b   or false and true != false + 2 * 4 ^
 A19: Nodes<Defn> 
1:1-1:61
 A18: DefFunDefn f 
1:1-1:61
 A15: Nodes<ParDefn> 
 A0: AtomType VOID 
1:11-1:14
 A17: Exprs 
1:18-1:61
 A16: Nodes<Expr> 
1:18-1:61
 A14: AsgnExpr 
1:18-1:61
 A1: NameExpr a 
1:18-1:18
 A13: BinExpr OR 
1:22-1:61
 A2: NameExpr b 
1:22-1:22
 A12: BinExpr AND 
1:29-1:61
 A3: AtomExpr false 
1:29-1:33
 A11: BinExpr NEQ 
1:39-1:61
 A4: AtomExpr true 
1:39-1:42
 A10: BinExpr ADD 
1:47-1:61
 A5: AtomExpr false 
1:47-1:51
 A9: BinExpr MUL 
1:55-1:61
 A6: AtomExpr 2 
1:55-1:55
 A8: SfxExpr PTR 
1:59-1:61
 A7: AtomExpr 4 
1:59-1:59

test1.p26

typ test = (a: int, b: char)
 A7: Nodes<Defn> 
1:1-1:28
 A6: TypDefn test 
1:1-1:28
 A5: StrType 
1:12-1:28
 A4: Nodes<CompDefn> 
1:13-1:27
 A1: CompDefn a 
1:13-1:18
 A0: AtomType INT 
1:16-1:18
 A3: CompDefn b 
1:21-1:27
 A2: AtomType CHAR 
1:24-1:27

test2.p26

// defnList test
fun f() : int = let typ a = int typ b = int in a, b end

 A15: Nodes<Defn> 
2:1-4:0
 A14: DefFunDefn f 
2:1-2:55
 A11: Nodes<ParDefn> 
 A0: AtomType INT 
2:11-2:13
 A13: Exprs 
2:17-2:55
 A12: Nodes<Expr> 
2:17-2:55
 A10: LetExpr 
2:17-2:55
 A7: Nodes<Defn> 
2:21-2:43
 A2: TypDefn a 
2:21-2:31
 A1: AtomType INT 
2:29-2:31
 A4: TypDefn b 
2:33-2:43
 A3: AtomType INT 
2:41-2:43
 A9: Exprs 
2:48-2:51
 A8: Nodes<Expr> 
2:48-2:51
 A5: NameExpr a 
2:48-2:48
 A6: NameExpr b 
2:51-2:51

test3.p26

typ idt = int

var idv : [10]idt

fun idf ( id1 : T1 , id2 : T2 , id3 : T3 ) : idt

fun idff ( abc : id) : idt = 1, 2, 3, while 2 do 1, 2, 3 end
 A31: Nodes<Defn> 
1:1-7:60
 A1: TypDefn idt 
1:1-1:13
 A0: AtomType INT 
1:11-1:13
 A4: VarDefn idv 
3:1-3:17
 A3: ArrType ArrType[10] 
3:11-3:17
 A2: NameType idt 
3:15-3:17
 A13: ExtFunDefn idf 
5:1-5:48
 A12: Nodes<ParDefn> 
5:9-5:42
 A6: ParDefn id1 
5:11-5:18
 A5: NameType T1 
5:17-5:18
 A8: ParDefn id2 
5:22-5:29
 A7: NameType T2 
5:28-5:29
 A10: ParDefn id3 
5:33-5:40
 A9: NameType T3 
5:39-5:40
 A11: NameType idt 
5:46-5:48
 A30: DefFunDefn idff 
7:1-7:60
 A27: Nodes<ParDefn> 
7:10-7:20
 A15: ParDefn abc 
7:12-7:19
 A14: NameType id 
7:18-7:19
 A16: NameType idt 
7:24-7:26
 A29: Exprs 
7:30-7:60
 A28: Nodes<Expr> 
7:30-7:60
 A17: AtomExpr 1 
7:30-7:30
 A18: AtomExpr 2 
7:33-7:33
 A19: AtomExpr 3 
7:36-7:36
 A26: WhileExpr 
7:39-7:60
 A20: AtomExpr 2 
7:45-7:45
 A25: Exprs 
7:50-7:56
 A24: Nodes<Expr> 
7:50-7:56
 A21: AtomExpr 1 
7:50-7:50
 A22: AtomExpr 2 
7:53-7:53
 A23: AtomExpr 3 
7:56-7:56

test4.p26

typ id = ^^^^^^^^^^^^^^void
typ id2 = [1][2][4]bool

var id3 : (a:[1][2][4]bool, b: ^^^^^^^^^^^^^^void, c: randomid, d : int, e : bool, f : char, g : { h : ^^int, i: void} )
 A62: Nodes<Defn> 
1:1-5:0
 A15: TypDefn id 
1:1-1:27
 A14: PtrType 
1:10-1:27
 A13: PtrType 
1:11-1:27
 A12: PtrType 
1:12-1:27
 A11: PtrType 
1:13-1:27
 A10: PtrType 
1:14-1:27
 A9: PtrType 
1:15-1:27
 A8: PtrType 
1:16-1:27
 A7: PtrType 
1:17-1:27
 A6: PtrType 
1:18-1:27
 A5: PtrType 
1:19-1:27
 A4: PtrType 
1:20-1:27
 A3: PtrType 
1:21-1:27
 A2: PtrType 
1:22-1:27
 A1: PtrType 
1:23-1:27
 A0: AtomType VOID 
1:24-1:27
 A20: TypDefn id2 
2:1-2:23
 A19: ArrType ArrType[1] 
2:11-2:23
 A18: ArrType ArrType[2] 
2:14-2:23
 A17: ArrType ArrType[4] 
2:17-2:23
 A16: AtomType BOOL 
2:20-2:23
 A61: VarDefn id3 
4:1-4:120
 A60: StrType 
4:11-4:120
 A59: Nodes<CompDefn> 
4:12-4:118
 A25: CompDefn a 
4:12-4:26
 A24: ArrType ArrType[1] 
4:14-4:26
 A23: ArrType ArrType[2] 
4:17-4:26
 A22: ArrType ArrType[4] 
4:20-4:26
 A21: AtomType BOOL 
4:23-4:26
 A41: CompDefn b 
4:29-4:49
 A40: PtrType 
4:32-4:49
 A39: PtrType 
4:33-4:49
 A38: PtrType 
4:34-4:49
 A37: PtrType 
4:35-4:49
 A36: PtrType 
4:36-4:49
 A35: PtrType 
4:37-4:49
 A34: PtrType 
4:38-4:49
 A33: PtrType 
4:39-4:49
 A32: PtrType 
4:40-4:49
 A31: PtrType 
4:41-4:49
 A30: PtrType 
4:42-4:49
 A29: PtrType 
4:43-4:49
 A28: PtrType 
4:44-4:49
 A27: PtrType 
4:45-4:49
 A26: AtomType VOID 
4:46-4:49
 A43: CompDefn c 
4:52-4:62
 A42: NameType randomid 
4:55-4:62
 A45: CompDefn d 
4:65-4:71
 A44: AtomType INT 
4:69-4:71
 A47: CompDefn e 
4:74-4:81
 A46: AtomType BOOL 
4:78-4:81
 A49: CompDefn f 
4:84-4:91
 A48: AtomType CHAR 
4:88-4:91
 A58: CompDefn g 
4:94-4:118
 A57: UniType 
4:98-4:118
 A56: Nodes<CompDefn> 
4:98-4:118
 A53: CompDefn h 
4:100-4:108
 A52: PtrType 
4:104-4:108
 A51: PtrType 
4:105-4:108
 A50: AtomType INT 
4:106-4:108
 A55: CompDefn i 
4:111-4:117
 A54: AtomType VOID 
4:114-4:117

test5.p26

var id4 : (a:[1][2][4]bool, b: ^^^^^^^^^^^^^^void, c: randomid, x: (d : int, e : bool, f : char, g : { h : ^^int, i: void}) )
 A44: Nodes<Defn> 
1:1-1:125
 A43: VarDefn id4 
1:1-1:125
 A42: StrType 
1:11-1:125
 A41: Nodes<CompDefn> 
1:12-1:123
 A4: CompDefn a 
1:12-1:26
 A3: ArrType ArrType[1] 
1:14-1:26
 A2: ArrType ArrType[2] 
1:17-1:26
 A1: ArrType ArrType[4] 
1:20-1:26
 A0: AtomType BOOL 
1:23-1:26
 A20: CompDefn b 
1:29-1:49
 A19: PtrType 
1:32-1:49
 A18: PtrType 
1:33-1:49
 A17: PtrType 
1:34-1:49
 A16: PtrType 
1:35-1:49
 A15: PtrType 
1:36-1:49
 A14: PtrType 
1:37-1:49
 A13: PtrType 
1:38-1:49
 A12: PtrType 
1:39-1:49
 A11: PtrType 
1:40-1:49
 A10: PtrType 
1:41-1:49
 A9: PtrType 
1:42-1:49
 A8: PtrType 
1:43-1:49
 A7: PtrType 
1:44-1:49
 A6: PtrType 
1:45-1:49
 A5: AtomType VOID 
1:46-1:49
 A22: CompDefn c 
1:52-1:62
 A21: NameType randomid 
1:55-1:62
 A40: CompDefn x 
1:65-1:123
 A39: StrType 
1:68-1:123
 A38: Nodes<CompDefn> 
1:69-1:122
 A24: CompDefn d 
1:69-1:75
 A23: AtomType INT 
1:73-1:75
 A26: CompDefn e 
1:78-1:85
 A25: AtomType BOOL 
1:82-1:85
 A28: CompDefn f 
1:88-1:95
 A27: AtomType CHAR 
1:92-1:95
 A37: CompDefn g 
1:98-1:122
 A36: UniType 
1:102-1:122
 A35: Nodes<CompDefn> 
1:102-1:122
 A32: CompDefn h 
1:104-1:112
 A31: PtrType 
1:108-1:112
 A30: PtrType 
1:109-1:112
 A29: AtomType INT 
1:110-1:112
 A34: CompDefn i 
1:115-1:121
 A33: AtomType VOID 
1:118-1:121

test6.p26

var rav : { a: {}, b: (:{a: ( g : int)}:bool)}
 A17: Nodes<Defn> 
1:1-1:46
 A16: VarDefn rav 
1:1-1:46
 A15: UniType 
1:11-1:46
 A14: Nodes<CompDefn> 
1:11-1:46
 A2: CompDefn a 
1:13-1:17
 A1: UniType 
1:16-1:17
 A0: Nodes<CompDefn> 
 A13: CompDefn b 
1:20-1:45
 A12: FunType 
1:23-1:45
 A11: Nodes<Type> 
1:25-1:39
 A9: UniType 
1:25-1:39
 A8: Nodes<CompDefn> 
1:25-1:39
 A7: CompDefn a 
1:26-1:38
 A6: StrType 
1:29-1:38
 A5: Nodes<CompDefn> 
1:31-1:37
 A4: CompDefn g 
1:31-1:37
 A3: AtomType INT 
1:35-1:37
 A10: AtomType BOOL 
1:41-1:44

test7.p26

typ t = (((id)))
typ t2 = (id: (int))
typ t3 = (((({}))))
 A10: Nodes<Defn> 
1:1-3:19
 A1: TypDefn t 
1:1-1:16
 A0: NameType id 
1:9-1:16
 A6: TypDefn t2 
2:1-2:20
 A5: StrType 
2:10-2:20
 A4: Nodes<CompDefn> 
2:11-2:19
 A3: CompDefn id 
2:11-2:19
 A2: AtomType INT 
2:15-2:19
 A9: TypDefn t3 
3:1-3:19
 A8: UniType 
3:10-3:19
 A7: Nodes<CompDefn> 

test8.p26

fun abc () : (a:[1][2][4]bool, b: ^^^^^^^^^^^^^^void, c: randomid, x: (d : int, e : bool, f : char, g : { h : ^^int, i: void}) )

 A45: Nodes<Defn> 
1:1-3:0
 A44: ExtFunDefn abc 
1:1-1:128
 A43: Nodes<ParDefn> 
 A42: StrType 
1:14-1:128
 A41: Nodes<CompDefn> 
1:15-1:126
 A4: CompDefn a 
1:15-1:29
 A3: ArrType ArrType[1] 
1:17-1:29
 A2: ArrType ArrType[2] 
1:20-1:29
 A1: ArrType ArrType[4] 
1:23-1:29
 A0: AtomType BOOL 
1:26-1:29
 A20: CompDefn b 
1:32-1:52
 A19: PtrType 
1:35-1:52
 A18: PtrType 
1:36-1:52
 A17: PtrType 
1:37-1:52
 A16: PtrType 
1:38-1:52
 A15: PtrType 
1:39-1:52
 A14: PtrType 
1:40-1:52
 A13: PtrType 
1:41-1:52
 A12: PtrType 
1:42-1:52
 A11: PtrType 
1:43-1:52
 A10: PtrType 
1:44-1:52
 A9: PtrType 
1:45-1:52
 A8: PtrType 
1:46-1:52
 A7: PtrType 
1:47-1:52
 A6: PtrType 
1:48-1:52
 A5: AtomType VOID 
1:49-1:52
 A22: CompDefn c 
1:55-1:65
 A21: NameType randomid 
1:58-1:65
 A40: CompDefn x 
1:68-1:126
 A39: StrType 
1:71-1:126
 A38: Nodes<CompDefn> 
1:72-1:125
 A24: CompDefn d 
1:72-1:78
 A23: AtomType INT 
1:76-1:78
 A26: CompDefn e 
1:81-1:88
 A25: AtomType BOOL 
1:85-1:88
 A28: CompDefn f 
1:91-1:98
 A27: AtomType CHAR 
1:95-1:98
 A37: CompDefn g 
1:101-1:125
 A36: UniType 
1:105-1:125
 A35: Nodes<CompDefn> 
1:105-1:125
 A32: CompDefn h 
1:107-1:115
 A31: PtrType 
1:111-1:115
 A30: PtrType 
1:112-1:115
 A29: AtomType INT 
1:113-1:115
 A34: CompDefn i 
1:118-1:124
 A33: AtomType VOID 
1:121-1:124

test9.p26

fun id ( id : idt ) : (a:[1][2][4][12]void) = ide, 1, true, false, 'a', "niz", "niz spet", none, nil
 A23: Nodes<Defn> 
1:1-1:100
 A22: DefFunDefn id 
1:1-1:100
 A19: Nodes<ParDefn> 
1:8-1:19
 A1: ParDefn id 
1:10-1:17
 A0: NameType idt 
1:15-1:17
 A9: StrType 
1:23-1:43
 A8: Nodes<CompDefn> 
1:24-1:42
 A7: CompDefn a 
1:24-1:42
 A6: ArrType ArrType[1] 
1:26-1:42
 A5: ArrType ArrType[2] 
1:29-1:42
 A4: ArrType ArrType[4] 
1:32-1:42
 A3: ArrType ArrType[12] 
1:35-1:42
 A2: AtomType VOID 
1:39-1:42
 A21: Exprs 
1:47-1:100
 A20: Nodes<Expr> 
1:47-1:100
 A10: NameExpr ide 
1:47-1:49
 A11: AtomExpr 1 
1:52-1:52
 A12: AtomExpr true 
1:55-1:58
 A13: AtomExpr false 
1:61-1:65
 A14: AtomExpr 'a' 
1:68-1:70
 A15: AtomExpr "niz" 
1:73-1:77
 A16: AtomExpr "niz spet" 
1:80-1:89
 A17: AtomExpr none 
1:92-1:95
 A18: AtomExpr nil 
1:98-1:100