simple-interpreter/parser.js at master · considerate/simple-interpreter · GitHub

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
module.exports = parse;

function parse(tokens) {
 	function peek(tokens, type, count) {
 		count = count || 1;
 		var token = tokens[0];
 		if(token.type === type) {
 			return true;
 		}
 		return false;
 	}
 	function consume(tokens, type) {
 		if(peek(tokens,type)) {
 			//Remove first element and return it
 			return tokens.shift();
 		}
 		return false;
 	}

 	function parseExpression(tokens) {
 		var result;
 		result = consume(tokens,'number');
 		var types = ['identifier', 'number'];
 		for(var i = 0; i < types.length; i++) {
 			var type = types[i];
 		 	result = consume(tokens,type);
	 		if(result) {
	 			return result;
	 		}
 		}
		throw new Error('Syntax error. No expression found.');
 	}

 	function peekExpression(tokens) {
  		var types = ['identifier', 'number'];
  		var start = false;
 		for(var i = 0; i < types.length; i++) {
 			var type = types[i];
 		 	if(peek(tokens,type)) {
 		 		start = true;
 		 		break;
 		 	}
 		}
 		if(!start) {
 			return false;
 		}
 		var operator = consume(tokens,'operator');
 		if(operator) {
 			if(operator.src === ':') {
 				return false;
 			}
 			return peekExpression(tokens);
 		} else {
 			return true;
 		}
 	}

 	function peekAssignment(tokens) {
 		var clone = tokens.slice();
 		if(!consume(clone, 'identifier')) {
 			return false;
 		}
 		consume(clone,'space');
 		var operator = consume(clone, 'operator');
 		if(!operator) {
 			return false;
 		}
 		if(operator.src !== ':') {
 			return false;
 		}
 		consume(clone,'space');
 		if(!peekExpression(clone)) {
 			return false;
 		}
 		return true;
 	}

 	function peekStatement(tokens) {
 		var clone = tokens.slice();
 		return peekAssignment(clone);
 	}

 	function parseExpressionStatement(tokens) {
    	var types = ['identifier', 'number'];
 		for(var i = 0; i < types.length; i++) {
 			var type = types[i];
 		 	if(peek(tokens,type)) {
 		 		var token = consume(tokens,type);
 		 		return {
 		 			type: 'expression',
 		 			expressionType: type,
 		 			src: token.src
 		 		}
 		 	}
 		}
 		throw new Error('Compiler error.');
 	}

 	function parseExpression(tokens) {
 		var expressionStatement = parseExpressionStatement(tokens);
 		consume(tokens,'space');
 		var operator = consume(tokens,'operator')
 		consume(tokens,'space');
 		if(operator) {
 			if(operator.src === '+') {
 				var right = parseExpression(tokens);
 				return {
 					type: 'expression',
 					expressionType: 'operator',
 					operator: '+',
 					left: expressionStatement,
 					right: right
 				}
 			}
 		} else {
 			return expressionStatement;
 		}
 	}

 	function parseAssignment(tokens) {
 		var identifier = consume(tokens,'identifier');
 		consume(tokens,'space');
 		consume(tokens,'operator');
 		consume(tokens,'space');
 		var expression = parseExpression(tokens);
 		return {
 			type: 'statement',
 			statementType: 'assignment',
 			left: identifier,
 			right: expression
 		};
 	}

 	function parseStatement(tokens) {
 		if(peekAssignment(tokens)) {
 			return parseAssignment(tokens);
 		}
 	}

 	var program = [];
 	while(tokens.length > 0) {
 		if(peekStatement(tokens)) {
 			var statement = parseStatement(tokens);
 			program.push(statement);
 			var consumed = consume(tokens, 'fullstop');
 			if(!consumed) {
 				console.log('No end of statement, missing ".".');
 			}
 		} else if(peekExpression(tokens)) {
 			var expression = parseExpression(tokens);
 			program.push(expression);
 			var consumed = consume(tokens, 'fullstop');
 			if(!consumed) {
 				console.log('No end of expression, missing ".".');
 			}
 		} else if (peek(tokens,'space')) {
 			consume(tokens,'space');
 		}
 		else {
 			console.log('error, invalid token: '+ JSON.stringify(tokens[0]));
 			return false;
 		}
 	}
 	return program;
}