blob: bec5b91b1d8093fe9e762cec751b45e0e29e7966 (
plain)
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
|
import { Token, TokenType } from "./Token";
export class ParseTree {
/**
* Create a tree from tokens. This consumes the tokens.
* @param tokens The tokens to create a tree for.
* @param inNested If currently allready nesting.
*/
public static CreateTree(tokens: Token[], inNested: boolean = false): ParseTree {
const tree: ParseTree = new ParseTree();
while (tokens.length > 0) {
const token: Token = tokens.shift();
switch (token.Type) {
case TokenType.OpenParenthesis:
tree.nodes.push(this.CreateTree(tokens, true));
break;
case TokenType.CloseParenthesis:
if (inNested === false) {
throw new Error("Unmatched closing parenthesis.");
}
return tree;
default:
tree.nodes.push(token);
break;
}
}
if (inNested === true) {
throw new Error("No match found for an opening parenthesis.");
}
return tree;
}
public nodes: Array<Token | ParseTree> = [];
/**
* Compact empty branches. Example ((foo))(((bar))) will become (foo)(bar)
* @param tree The ParseTree to compact. Defaults to the current tree.
*/
public Compact(tree: ParseTree = this): ParseTree {
const newTree: ParseTree = new ParseTree();
newTree.nodes = tree.nodes.map((n) => n);
const isNotCompact = (n) => n instanceof ParseTree && n.nodes.length === 1 && n.nodes[0] instanceof ParseTree;
// Compact current level of nodes to the maximum amount.
while (newTree.nodes.some((n) => isNotCompact(n))) {
newTree.nodes = newTree.nodes
.map((n) => n instanceof ParseTree && isNotCompact(n) ? n.nodes[0] : n);
}
// Compact all nested parsetrees.
newTree.nodes = newTree.nodes
.map((n) => n instanceof ParseTree ? this.Compact(n) : n);
return newTree;
}
/**
* Copy parsetree.
* @param tree The ParseTree to compact. Defaults to the current tree.
*/
public Copy(tree: ParseTree = this): ParseTree {
const newTree: ParseTree = new ParseTree();
newTree.nodes = tree.nodes
.map((n) => n instanceof Token ? n : this.Copy(n));
return newTree;
}
/**
* Create string from the parsetree which is a representation of the original code.
* @param tree The ParseTree to compact. Defaults to the current tree.
*/
public Yield(tree: ParseTree = this): string {
let code: string = "";
for (const node of tree.nodes) {
if (node instanceof ParseTree) {
code += "(" + this.Yield(node) + ")";
continue;
}
switch (node.Type) {
case TokenType.Symbol:
code += code === "" ? node.Value : " " + node.Value;
break;
case TokenType.Pointer:
code += node.Value;
break;
case TokenType.Reference:
code += node.Value;
break;
case TokenType.ArraySubscript:
code += node.Value;
break;
case TokenType.CurlyBlock:
code += node.Value;
break;
case TokenType.Assignment:
code += " " + node.Value;
break;
case TokenType.Comma:
code += node.Value;
break;
case TokenType.Arrow:
code += " " + node.Value;
break;
case TokenType.Ellipsis:
code += node.Value;
break;
case TokenType.Attribute:
code += code === "" ? node.Value : " " + node.Value;
break;
}
}
return code;
}
}
|