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
|
import TokenType.*
import exceptions.*
class Syntax {
/**
* Checks and validates whether the code complies with the syntax/grammar rules
*/
fun check(statements: MutableList<MutableList<Token>>): Boolean {
statements.forEach { statement ->
removePadding(statement)
mergeStrings(statement)
mergeTokens(statement)
checkFirst(statement)
statement.forEach { println("${it.content} ${it.type}") }
statement.forEachIndexed { j, token ->
checkBrackets(statement, token)
checkNext(statement, token, j)
}
}
return true
}
/**
* Removes empty characters from the start and end of statements
*/
private fun removePadding(statement: MutableList<Token>) {
while (statement[0].type == Empty)
statement.removeAt(0)
while (statement[statement.size - 1].type == Empty)
statement.removeAt(statement.size - 1)
}
/**
* Merges classified strings to constants
*/
private fun mergeStrings(statement: MutableList<Token>) {
var stringing = false
statement.forEachIndexed { i, token ->
if (token.type == Classifier)
stringing = !stringing
if (stringing || token.type == Classifier) {
token.type = Constant
statement[i] = token
}
}
}
/**
* Merges tokens by same type
*/
private fun mergeTokens(statement: MutableList<Token>) {
var i = 0
while (statement.size > i + 1) {
if (statement[i].type == statement[i + 1].type) { // TODO: Differentiate int and string
statement[i].content = statement[i].content + statement[i + 1].content
statement.removeAt(i + 1)
i--
}
i++
}
}
/**
* Specifies which token types are allowed at the beginning of a statement
*/
private fun checkFirst(statement: MutableList<Token>) {
val token = statement[0]
if (token.type !in listOf(Keyword, Function, Variable))
throw SyntaxError(token.type.toString().toLowerCase(), token.content, token.lineNumber)
}
/**
* Checks whether the count of brackets is equal
*/
private fun checkBrackets(statement: MutableList<Token>, token: Token) {
if (statement.count { it.type == OpenedBracket } != statement.count { it.type == ClosedBracket })
throw SyntaxError("Bracket", "Brackets are not even", token.lineNumber)
}
/**
* Specifies and checks the tokens which are allowed to follow after [token]
*/
private fun checkNext(statement: MutableList<Token>, token: Token, index: Int) {
when (token.type) {
Keyword -> allowNext(statement, index, listOf(OpenedBracket))
Function -> allowNext(statement, index, listOf(OpenedBracket))
Constant -> allowNext(statement, index, listOf(Comparison, Arithmetic, Logical, ClosedBracket, StatementEnd))
Assignment -> allowNext(statement, index, listOf(Constant, Function, Variable))
Arithmetic -> allowNext(statement, index, listOf(Constant, Function, Variable))
Comparison -> allowNext(statement, index, listOf(Constant, Function, Variable))
Logical -> allowNext(statement, index, listOf(Constant, Function, Variable))
Variable -> allowNext(statement, index, listOf(Assignment, ClosedBracket, Arithmetic, Logical, Comparison))
Punctuation -> allowNext(statement, index, listOf(Constant))
OpenedBracket -> allowNext(statement, index, listOf(Constant, Variable, ClosedBracket))
ClosedBracket -> allowNext(statement, index, listOf(Arithmetic, Comparison, Logical, OpenedBracket, StatementEnd))
Classifier -> Unit
Empty -> Unit
StatementEnd -> Unit
Skip -> throw LexicalError(token.content)
}
}
/**
* Throws [SyntaxError] if the next token is not in [allowed]
*/
private fun allowNext(statement: MutableList<Token>, index: Int, allowed: List<TokenType>) {
if (statement.size > index + 1 && nextNonEmpty(statement, index).type !in allowed) {
val token = nextNonEmpty(statement, index)
throw SyntaxError(token.type.toString().toLowerCase(), token.content, token.lineNumber)
}
}
}
|
