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