this repo has no description
dekker.one
1% A MiniZinc model
2<model> ::= [ <item> ";" ... ]
3
4% Items
5<item> ::= <include-item>
6 | <var-decl-item>
7 | <enum-item>
8 | <assign-item>
9 | <constraint-item>
10 | <solve-item>
11 | <output-item>
12 | <predicate-item>
13 | <test-item>
14 | <function-item>
15 | <annotation-item>
16
17<ti-expr-and-id> ::= <ti-expr> ":" <ident>
18
19% Include items
20<include-item> ::= "include" <string-literal>
21
22% Variable declaration items
23<var-decl-item> ::= <ti-expr-and-id> <annotations> [ "=" <expr> ]
24
25% Enum items
26<enum-item> ::= "enum" <ident> <annotations> [ "=" <enum-cases-list> ]
27
28<enum-cases-list> ::= <enum-cases>
29 | <enum-cases-list> "++" <enum-cases>
30
31<enum-cases> ::= "{" <ident> "," ... "}"
32 | <ident> "(" <ident> ")"
33
34% Assign items
35<assign-item> ::= <ident> "=" <expr>
36
37% Constraint items
38<constraint-item> ::= "constraint" <string-annotation> <expr>
39
40% Solve item
41<solve-item> ::= "solve" <annotations> "satisfy"
42 | "solve" <annotations> "minimize" <expr>
43 | "solve" <annotations> "maximize" <expr>
44
45% Output items
46<output-item> ::= "output" <expr>
47
48% Annotation items
49<annotation-item> ::= "annotation" <ident> <params>
50
51% Predicate, test and function items
52<predicate-item> ::= "predicate" <operation-item-tail>
53
54<test-item> ::= "test" <operation-item-tail>
55
56<function-item> ::= "function" <ti-expr> ":" <operation-item-tail>
57
58<operation-item-tail> ::= <ident> <params> <annotations> [ "=" <expr> ]
59
60<params> ::= [ ( <ti-expr-and-id> "," ... ) ]
61
62% Type-inst expressions
63<ti-expr> ::= <base-ti-expr>
64 | <array-ti-expr>
65
66<base-ti-expr> ::= <var-par> <opt-ti> <set-ti> <base-ti-expr-tail>
67
68<var-par> ::= "var" | "par" | ε
69
70<opt-ti> ::= "opt" | ε
71
72<set-ti> ::= "set" "of" | ε
73
74<base-type> ::= "bool"
75 | "int"
76 | "float"
77 | "string"
78
79<base-ti-expr-tail> ::= <ident>
80 | <base-type>
81 | <ti-variable-expr-tail>
82 | "ann"
83 | { <expr> "," ... }
84 | <num-expr> ".." <num-expr>
85
86% Type-inst variables
87<ti-variable-expr-tail> ::= $[A-Za-z][A-Za-z0-9_]*
88
89% Array type-inst expressions
90<array-ti-expr> ::= "array" [ <ti-expr> "," ... ] "of" <base-ti-expr>
91 | "list" "of" <base-ti-expr>
92
93% Expressions
94<expr> ::= <expr-atom> <expr-binop-tail>
95
96<expr-atom> ::= <expr-atom-head> <expr-atom-tail> <annotations>
97
98<expr-binop-tail> ::= [ <bin-op> <expr> ]
99
100<expr-atom-head> ::= <builtin-un-op> <expr-atom>
101 | "(" <expr> ")"
102 | <ident-or-quoted-op>
103 | "_"
104 | <bool-literal>
105 | <int-literal>
106 | <float-literal>
107 | <string-literal>
108 | <set-literal>
109 | <set-comp>
110 | <array-literal>
111 | <array-literal-2d>
112 | <array-comp>
113 | <ann-literal>
114 | <if-then-else-expr>
115 | <let-expr>
116 | <call-expr>
117 | <gen-call-expr>
118
119<expr-atom-tail> ::= ε
120 | <array-access-tail> <expr-atom-tail>
121
122% Numeric expressions
123<num-expr> ::= <num-expr-atom> <num-expr-binop-tail>
124
125<num-expr-atom> ::= <num-expr-atom-head> <expr-atom-tail> <annotations>
126
127<num-expr-binop-tail> ::= [ <num-bin-op> <num-expr> ]
128
129<num-expr-atom-head> ::= <builtin-num-un-op> <num-expr-atom>
130 | "(" <num-expr> ")"
131 | <ident-or-quoted-op>
132 | <int-literal>
133 | <float-literal>
134 | <if-then-else-expr>
135 | <let-expr>
136 | <call-expr>
137 | <gen-call-expr>
138
139% Built-in operators
140<builtin-op> ::= <builtin-bin-op> | <builtin-un-op>
141
142<bin-op> ::= <builtin-bin-op> | ‘<ident>‘
143
144<builtin-bin-op> ::= "<->" | "->" | "<-" | "\/" | "xor" | "/\" | "<" | ">" | "<=" | ">=" | "==" | "=" | "!="
145 | "in" | "subset" | "superset" | "union" | "diff" | "symdiff"
146 | ".." | "intersect" | "++" | <builtin-num-bin-op>
147
148<builtin-un-op> ::= "not" | <builtin-num-un-op>
149
150% Built-in numeric operators
151<num-bin-op> ::= <builtin-num-bin-op> | ‘<ident>‘
152
153<builtin-num-bin-op> ::= "+" | "-" | "*" | "/" | "div" | "mod" | "^"
154
155<builtin-num-un-op> ::= "+" | "-"
156
157% Boolean literals
158<bool-literal> ::= "false" | "true"
159
160% Integer literals
161<int-literal> ::= [0-9]+
162 | 0x[0-9A-Fa-f]+
163 | 0o[0-7]+
164
165% Float literals
166<float-literal> ::= [0-9]+"."[0-9]+
167 | [0-9]+"."[0-9]+[Ee][-+]?[0-9]+
168 | [0-9]+[Ee][-+]?[0-9]+
169 | 0[xX]([0-9a-fA-F]*"."[0-9a-fA-F]+|[0-9a-fA-F]+".")([pP][+-]?[0-9]+)
170 | (0[xX][0-9a-fA-F]+[pP][+-]?[0-9]+)
171
172% String literals
173<string-contents> ::= ([^"\n\] | \[^\n(])*
174
175<string-literal> ::= """ <string-contents> """
176 | """ <string-contents> "\(" <string-interpolate-tail>
177
178<string-interpolate-tail> ::= <expr> ")"<string-contents>"""
179 | <expr> ")"<string-contents>"\(" <string-interpolate-tail>
180
181% Set literals
182<set-literal> ::= "{" [ <expr> "," ... ] "}"
183
184% Set comprehensions
185<set-comp> ::= "{" <expr> "|" <comp-tail> "}"
186
187<comp-tail> ::= <generator> [ "where" <expr> ] "," ...
188
189<generator> ::= <ident> "," ... "in" <expr>
190
191% Array literals
192<array-literal> ::= "[" [ <expr> "," ... ] "]"
193
194% 2D Array literals
195<array-literal-2d> ::= "[|" [ (<expr> "," ...) "|" ... ] "|]"
196
197% Array comprehensions
198<array-comp> ::= "[" <expr> "|" <comp-tail> "]"
199
200% Array access
201<array-access-tail> ::= "[" <expr> "," ... "]"
202
203% Annotation literals
204<ann-literal> ::= <ident> [ "(" <expr> "," ... ")" ]
205
206% If-then-else expressions
207<if-then-else-expr> ::= "if" <expr> "then" <expr> [ "elseif" <expr> "then" <expr> ]* "else" <expr> "endif"
208
209% Call expressions
210<call-expr> ::= <ident-or-quoted-op> [ "(" <expr> "," ... ")" ]
211
212% Let expressions
213<let-expr> ::= "let" "{" <let-item> ";" ... "}" "in" <expr>
214
215<let-item> ::= <var-decl-item>
216 | <constraint-item>
217
218% Generator call expressions
219<gen-call-expr> ::= <ident-or-quoted-op> "(" <comp-tail> ")" "(" <expr> ")"
220
221% Miscellaneous
222
223% Identifiers
224<ident> ::= [A-Za-z][A-Za-z0-9_]* | ’[^’\xa\xd\x0]*’
225
226% Identifiers and quoted operators
227<ident-or-quoted-op> ::= <ident>
228 | ’<builtin-op>’
229
230% Annotations
231<annotations> ::= [ "::" <annotation> ]*
232
233<annotation> ::= <expr-atom-head> <expr-atom-tail>
234
235<string-annotation> ::= "::" <string-literal>