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
|
import {
type DenotableFunctionSignature,
Environment,
type Denotable,
} from '.';
const addUnaryIntegerOperationsTo = (env: Environment) => {
const unaryIntegerOperationSignatures: DenotableFunctionSignature[] = [
{
arguments: ['int'],
return: 'int',
},
];
for (const { name, fn } of [
{ name: '~', fn: (a: number) => ~a },
{ name: '!', fn: (a: number) => (!a ? 1 : 0) },
]) {
env.set(name, {
type: 'function',
value: {
signatures: unaryIntegerOperationSignatures,
body: ({ value }: Denotable) => fn(value as number),
},
});
}
return env;
};
const addBinaryIntegerOperationsTo = (env: Environment) => {
const binaryIntegerOperationSignatures: DenotableFunctionSignature[] = [
{
arguments: ['int', 'int'],
return: 'int',
},
];
for (const { name, fn } of [
{ name: '%', fn: (a: number, b: number) => a % b },
{ name: '>>', fn: (a: number, b: number) => a >> b },
{ name: '<<', fn: (a: number, b: number) => a << b },
{ name: '|', fn: (a: number, b: number) => a | b },
{ name: '^', fn: (a: number, b: number) => a ^ b },
{ name: '&&', fn: (a: number, b: number) => (a && b ? 1 : 0) },
{ name: '<=', fn: (a: number, b: number) => (a <= b ? 1 : 0) },
{ name: '<', fn: (a: number, b: number) => (a < b ? 1 : 0) },
{ name: '>', fn: (a: number, b: number) => (a > b ? 1 : 0) },
{ name: '>=', fn: (a: number, b: number) => (a >= b ? 1 : 0) },
{ name: '||', fn: (a: number, b: number) => (a || b ? 1 : 0) },
]) {
env.set(name, {
type: 'function',
value: {
signatures: binaryIntegerOperationSignatures,
body: ({ value: a }: Denotable, { value: b }: Denotable) =>
fn(a as number, b as number),
},
});
}
return env;
};
const addBinaryArithmeticOperationsTo = (env: Environment) => {
const binaryArithmeticSignatures: DenotableFunctionSignature[] = [
{
arguments: ['int', 'int'],
return: 'int',
},
{
arguments: [
['int', 'real'],
['int', 'real'],
],
return: 'real',
},
];
for (const { name, fn } of [
{ name: '+', fn: (a: number, b: number) => a + b },
{ name: '-', fn: (a: number, b: number) => a - b },
{ name: '*', fn: (a: number, b: number) => a * b },
{ name: '/', fn: (a: number, b: number) => a / b },
{ name: '**', fn: (a: number, b: number) => a ** b },
]) {
env.set(name, {
type: 'function',
value: {
signatures: binaryArithmeticSignatures,
body: ({ value: a }: Denotable, { value: b }: Denotable) =>
fn(a as number, b as number),
},
});
}
return env;
};
export const putBuiltinsOnEnvironemtn = (env: Environment) => {
return [
addBinaryArithmeticOperationsTo,
addBinaryIntegerOperationsTo,
addUnaryIntegerOperationsTo,
].reduce((acc, builtinsAdder) => builtinsAdder(acc), env);
};
|
