-
Notifications
You must be signed in to change notification settings - Fork 0
/
Example.ts
218 lines (188 loc) · 5.57 KB
/
Example.ts
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
/**
* @requires 'js-ds-language-framework'
*/
/**
* Commons is just a library with common classes
* That is very convenience to use
*/
import { Commons, Scanner, Parser } from 'js-ds-language-framework';
import Token = Scanner.Token.Base;
import CreateToken = Scanner.Token.Create;
import BasicTokenTypes = Scanner.Token.Types.Basic;
import Terminal = Parser.Nodes.Categories.Terminal;
/**
* @classdesc
* This is example of scanner component usage
* This component scans number from input through Commons.Cursor class
*/
class NumberScanner implements Scanner.Component {
/**
* Just cozy method to check that characters meets conditions
*
* @param {string} character
* @returns {boolean}
*/
private Match(character: string): boolean {
return /[0-9\.]/.test(character);
}
/**
* @description
* This is the main method of this class
* It provides the strategy of scanning
*
* @param {Scanner.Context} context - execution context of this scanner component
* @param {Scanner.Types.Cursor} cursor - cursor to given input string
*
* @implements {Scanner.Component}
*
* @returns {Scanner.Token.Base | void}
*/
public Scan(context: Scanner.Context, cursor: Scanner.Types.Cursor): Token | void {
const accumulator: Scanner.Types.Accumulator = new Commons.Accumulator(x => this.Match(x));
/**
* Accumulator accumulates characters from cursor
* As long as it matches condition
*/
for (cursor; accumulator.Matches(cursor.Current()); cursor.Next()) {
accumulator.Accumulate(cursor.Current());
}
/**
* If accumulator results is not empty
* Then creates token with type number and such value and returns it
* Else returns nothing
*/
if (accumulator.Empty == false) {
return CreateToken(BasicTokenTypes.Number, accumulator.Result.join(Commons.Constants.EMPTY_STRING));
}
}
}
type ArithmeticalNode = Parser.Nodes.Executable<number>
/**
* @classdesc
* This class simulates executable node
* That presents number in our programming language
*/
class NumberNode implements ArithmeticalNode {
public constructor(private _value: number) {}
/**
* @description
* It is the main method of this class
* It provides strategy of execution
*
* @param {Parser.Nodes.Additional.Context} context - execution context of this node
*/
public Execute(context: Parser.Nodes.Additional.Context): number {
return this._value as number;
}
}
/**
* @classdesc
* This class simulates executable node
* That presents number in our programming language
*/
class NumberParser implements Parser.Components.Base<ArithmeticalNode> {
/**
* @warning
* Pay attention to this fact that you need to pass through constructor
* Cursor to stream of tokens
*
* @param {Parser.Types.Cursor} _cursor
*/
public constructor(private _cursor: Parser.Types.Cursor) {}
/**
* @description
* method Match() is just for convience in work with tokens
*
* @param {Parser.Types.Token} token
*/
private Match(token: Parser.Types.Token): boolean {
return token.type.Equals(BasicTokenTypes.Number);
}
/**
* @description
* This is the main method of this class
* It provides strategy of parsing
*
* @param { Parser.Layer<void | ArithmeticalNode>} layer - current layer parser
*
* @returns {void | ArithmeticalNode}
*/
public Parse(layer: Parser.Layer.Base<Terminal<ArithmeticalNode>>): Terminal<ArithmeticalNode> {
/**
* If this parser finds token with type "number" then returns instance of NumberNode
* Else returns nothing
*/
if (this.Match(this._cursor.Current())) {
const number: number = parseFloat(this._cursor.Current().value)
this._cursor.Next()
return new NumberNode(number)
}
}
}
/**
* Now we should do basic configuration
*/
class EmptyScannerContext implements Scanner.Context {}
class EmptyParserContext implements Parser.Nodes.Additional.Context {}
/**
* Try to pass different value to input
*/
const input: string = `100`
const cursorToInput = new Commons.Cursor<string>(input.split(Commons.Constants.EMPTY_STRING))
/**
* @warning
* Scanner can be used just once!
* You should recreate the scanner and reconfigure everytime you want to use this
* You can solve this problem by pattern factory
*
* @description
* Generates stream of tokens
*/
const scanner = new Scanner.Base(cursorToInput)
/**
* @description
* Require to scanner our scanner of numbers
*/
scanner.Use(() => new NumberScanner())
const tokens = scanner.Scan(new EmptyScannerContext())
/**
* Test it yourself!
* This should output:
* [
* {
* type: Type { _type: 'number' },
* value: '100',
* placement: undefined
* }
* ]
*/
console.log(tokens)
const cursorToTokens = new Commons.Cursor(tokens)
/**
* @warning
* Parser can be used just once!
* You should recreate the parser and reconfigure everytime you want to use this
* You can solve this problem by pattern factory
*
* @description
* Generates stream of tokens
*/
const parser = new Parser.Base<ArithmeticalNode>(cursorToTokens)
parser.UseTerminal(() => new NumberParser(cursorToTokens))
const ast = parser.Parse()
/**
* Test it yourself!
* Outputs: [ NumberNode { _value: 100 } ]
*/
console.log(ast)
const parserContext = new EmptyParserContext()
/**
* Test it yourself!
* Outputs: 100
*/
ast.forEach(node => console.log(node.Execute(parserContext)))
/**
* Great! You just created your first programming language
* Keep going to learn this framework if you want!
* Thank you very much for your attention!
*/