Compiler-Construction-Project/langwej.cfg at master · Nandy-006/Compiler-Construction-Project · 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
program -> funcOrStatement
program -> ''
funcOrStatement -> functionDefinition funcOrStatement
funcOrStatement -> statement funcOrStatement
funcOrStatement -> ''

arithmeticOperator -> +
arithmeticOperator -> -
arithmeticOperator -> *
arithmeticOperator -> /
arithmeticOperator -> %

relationalOperator -> >
relationalOperator -> <
relationalOperator -> >=
relationalOperator -> <=
relationalOperator -> ==
relationalOperator -> !=

logicalOperator -> ||
logicalOperator -> &&

operator -> arithmeticOperator
functionName -> IDENTIFIER
operator -> logicalOperator

constant -> LITERAL_INT
constant -> LITERAL_FLOAT
constant -> booleanConstant
constant -> LITERAL_STRING
constant -> LITERAL_CHAR
constant -> null

booleanConstant -> stonks
booleanConstant -> not_stonks

arrayConstant -> [ ]
arrayConstant -> [ term commaConst ]
arrayConstant -> [ term ]
commaConst -> , term commaConst
commaConst -> , term

dataType -> intijur
dataType -> flote
dataType -> bulen
dataType -> strin
dataType -> char
dataType -> arrayType

arrayType -> array < elementType >
elementType -> flote
elementType -> bulen
elementType -> strin
elementType -> intijur

varName -> IDENTIFIER

term -> constant
term -> varName
term -> varName [ expression ]
term -> ( expression )
term -> functionCall
term -> ! term
term -> - term

statement -> declarationStatement
statement -> letStatement
statement -> ifStatement
statement -> whileStatement
statement -> callStatement
statement -> returnStatement

declarationStatement -> dataType declare ;
declare -> varName
declare -> varName = expression
declare -> varName , declare
declare -> varName = expression , declare

letStatement -> let varName [ expression ] = expression ;
letStatement -> let varName = expression ;
letStatement -> let varName = arrayExpression ;

ifStatement -> if ( expression ) { } else { }
ifStatement -> if ( expression ) { }
ifStatement -> if ( expression ) { } else { statements }
ifStatement -> if ( expression ) { statements }
ifStatement -> if ( expression ) { statements } else { }
ifStatement -> if ( expression ) { statements } else { statements }

whileStatement -> whil ( expression ) { statements }
whileStatement -> whil ( expression ) { }

callStatement -> coll functionCall ;

returnStatement -> retun expression ;
returnStatement -> retun arrayExpression ;

expression -> term operator expression
expression -> term relationalOperator expression
expression -> term

arrayExpression -> [ expression ]
arrayExpression -> [ expression commaExpr ]
commaExpr -> , expression commaExpr
commaExpr -> , expression

functionDefinition -> dataType funkshun functionName ( parameterList ) { statements returnStatement }
functionDefinition -> dataType funkshun functionName ( parameterList ) { returnStatement }
functionDefinition -> dataType funkshun functionName ( ) { statements returnStatement }
functionDefinition -> dataType funkshun functionName ( ) { returnStatement }
statements -> statements statement
statements -> statement

parameterList -> dataType IDENTIFIER commaDataID
parameterList -> dataType IDENTIFIER

commaDataID -> , dataType IDENTIFIER commaDataID
commaDataID -> , dataType IDENTIFIER

functionCall -> functionName ( )
functionCall -> functionName ( term commaTerm )
functionCall -> functionName ( term )
commaTerm -> , term commaTerm
commaTerm -> , term