Blender V5.3
operator.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "symbol_table.hh"
10
11namespace bsl {
12
13enum OperatorType : uint16_t {
14 /* clang-format off */
15 /* Operand Constraints (Bits 11..13) */
16 OP_NUMERIC = 0b0000'1000'0000'0000,
17 OP_INTEGER = 0b0001'0000'0000'0000,
18 OP_BOOL = 0b0010'0000'0000'0000,
19
20 /* Operator Categories (Bits 0..5) */
21 OP_ARITHMETIC = 0b0000'0000'0000'0001,
22 OP_BITWISE = 0b0000'0000'0000'0010,
23 OP_SHIFT = 0b0000'0000'0000'0100,
24 OP_EQUALITY = 0b0000'0000'0000'1000,
25 OP_RELATIONAL = 0b0000'0000'0001'0000,
26 OP_LOGICAL = 0b0000'0000'0010'0000,
27 OP_ASSIGN = 0b0000'0000'0100'0000,
28
29 /* clang-format on */
30
31 OP_INVALID = 0b1111'1111'1111'1111,
32};
33
35{
36 switch (tok_type) {
37 case Plus:
39 case Minus:
41 case Multiply:
43 case Divide:
45 case Increment:
47 case Decrement:
49
50 case Modulo:
52 case And:
54 case Or:
56 case Xor:
58 case BitwiseNot:
60
61 case LShift:
63 case RShift:
65
66 case Equal:
68 case NotEqual:
70
71 case LThan:
73 case GThan:
75 case LEqual:
77 case GEqual:
79
80 case Not:
81 return OperatorType(OP_BOOL);
82 case LogicalAnd:
84 case LogicalOr:
86
87 case Assign:
88 case AssignAdd:
89 case AssignSub:
90 case AssignMul:
91 case AssignDiv:
92 case AssignLShift:
93 case AssignRShift:
94 return OperatorType(OP_ASSIGN);
95 default:
96 return OP_INVALID;
97 }
98}
99
100namespace builtin {
101
103{
104 using namespace builtin;
105 /* Validate inputs and binary capability. */
107 return ClassId::Invalid;
108 }
109
110 const uint16_t l = uint16_t(lhs->builtin_class);
111 const uint16_t r = uint16_t(rhs->builtin_class);
112 const OperatorType o = to_operator_type(op);
113
114 if (o == OP_ASSIGN) {
115 return lhs->builtin_class;
116 }
117
118 if (l & MATRIX_MASK) {
119 uint16_t col = (l & MATRIX_MASK) >> MATRIX_SHIFT;
120 uint16_t row = l & LEN_MASK;
121 return (r == (CLASS_FLOAT | col)) ? ClassId(CLASS_FLOAT | row) : ClassId::Invalid;
122 }
123 if (r & MATRIX_MASK) {
124 uint16_t col = (r & MATRIX_MASK) >> MATRIX_SHIFT;
125 uint16_t row = r & LEN_MASK;
126 return (l == (CLASS_FLOAT | row)) ? ClassId(CLASS_FLOAT | col) : ClassId::Invalid;
127 }
128
129 /* Logical operators (&&, ||): scalar bool only. */
130 if (o & OP_LOGICAL) {
132 }
133
134 /* Enforce scalar base category (Numeric vs Integer). */
135 if ((o & OP_NUMERIC) && (!(l & FLAG_NUMERIC) || !(r & FLAG_NUMERIC))) {
136 return ClassId::Invalid;
137 }
138
139 if ((o & OP_INTEGER) && (!(l & FLAG_INTEGER) || !(r & FLAG_INTEGER))) {
140 return ClassId::Invalid;
141 }
142
143 const uint16_t l_len = l & LEN_MASK;
144 const uint16_t r_len = r & LEN_MASK;
145 assert(l_len != 0 && r_len != 0);
146
147 /* Bitwise Shifts (<<, >>): RHS must be scalar or match LHS length. */
148 if (o & OP_SHIFT) {
149 return (r_len == 1 || r_len == l_len) ? ClassId(l) : ClassId::Invalid;
150 }
151
152 /* Equality (==, !=): Scalars of exact matching base types only. */
153 if (o & OP_EQUALITY) {
154 /* Comparing float to int is not allowed. */
155 if ((l & FLAG_INTEGER) != (r & FLAG_INTEGER)) {
156 return ClassId::Invalid;
157 }
158 /* Comparing integers of different signedness is not allowed. */
159 if ((l & FLAG_SIGN) != (r & FLAG_SIGN)) {
160 /* TODO. Codebase still uses this. Patch it all at once. */
161 // return ClassId::Invalid;
162 }
163 return (l_len == 1 && r_len == 1) ? ClassId::bool_t : ClassId::Invalid;
164 }
165
166 /* Relational (<, >, <=, >=): Scalar numerics only. */
167 if (o & OP_RELATIONAL) {
168 return (l_len == 1 && r_len == 1) ? ClassId::bool_t : ClassId::Invalid;
169 }
170
171 uint16_t target_len = l_len;
172 if (l_len != r_len) {
173 /* Vector Dimension Promotion (Scalar-Vector / Vector-Scalar). */
174 if (l_len == 1) {
175 target_len = r_len;
176 }
177 else if (r_len == 1) {
178 target_len = l_len;
179 }
180 else {
181 return ClassId::Invalid;
182 }
183 }
184
185 /* Base Type Promotion: Higher rank base wins. */
186 const uint16_t l_rank = l & RANK_MASK;
187 const uint16_t r_rank = r & RANK_MASK;
188 const uint16_t promoted_base = (l_rank > r_rank) ? (l & BASE_MASK) : (r & BASE_MASK);
189
190 return static_cast<ClassId>(promoted_base | target_len);
191}
192
194{
195 using namespace builtin;
196 const uint16_t r = uint16_t(rhs->builtin_class);
197 const OperatorType o = to_operator_type(op);
198
199 if (r == ClassId::Invalid) {
200 return ClassId::Invalid;
201 }
202
203 if (r & CLASS_MAT && op == lexit::Minus) {
204 return rhs->builtin_class;
205 }
206 if (o & OP_BOOL) {
208 }
209 if ((o & OP_NUMERIC) && !(r & FLAG_NUMERIC)) {
210 return ClassId::Invalid;
211 }
212 if ((o & OP_INTEGER) && !(r & FLAG_INTEGER)) {
213 return ClassId::Invalid;
214 }
215
216 return rhs->builtin_class;
217}
218
220{
221 using namespace builtin;
222 const uint16_t l = uint16_t(lhs->builtin_class);
223 const OperatorType o = to_operator_type(op);
224
225 if (l == ClassId::Invalid) {
226 return ClassId::Invalid;
227 }
228
229 if ((o & OP_NUMERIC) && !(l & FLAG_NUMERIC)) {
230 return ClassId::Invalid;
231 }
232
233 return lhs->builtin_class;
234}
235
236} // namespace builtin
237
239{
240 switch (id) {
242 return bool_cls;
244 return bool2_cls;
246 return bool3_cls;
248 return bool4_cls;
250 return char_cls;
252 return char2_cls;
254 return char3_cls;
256 return char4_cls;
258 return float_cls;
260 return float2_cls;
262 return float3_cls;
264 return float4_cls;
266 return half_cls;
268 return half2_cls;
270 return half3_cls;
272 return half4_cls;
274 return int_cls;
276 return int2_cls;
278 return int3_cls;
280 return int4_cls;
282 return short_cls;
284 return short2_cls;
286 return short3_cls;
288 return short4_cls;
290 return uchar_cls;
292 return uchar2_cls;
294 return uchar3_cls;
296 return uchar4_cls;
298 return uint_cls;
300 return uint2_cls;
302 return uint3_cls;
304 return uint4_cls;
306 return ushort_cls;
308 return ushort2_cls;
310 return ushort3_cls;
312 return ushort4_cls;
314 return float2x2_cls;
316 return float2x3_cls;
318 return float2x4_cls;
320 return float3x2_cls;
322 return float3x3_cls;
324 return float3x4_cls;
326 return float4x2_cls;
328 return float4x3_cls;
330 return float4x4_cls;
331 default:
332 return err_cls;
333 }
334}
335
337{
338 /* Size 1 corresponds to the scalar base type itself. */
339 if (size == 1) {
340 return base;
341 }
342
343 if (base == float_cls) {
344 switch (size) {
345 case 2:
346 return float2_cls;
347 case 3:
348 return float3_cls;
349 case 4:
350 return float4_cls;
351 default:
352 break;
353 }
354 }
355 else if (base == int_cls) {
356 switch (size) {
357 case 2:
358 return int2_cls;
359 case 3:
360 return int3_cls;
361 case 4:
362 return int4_cls;
363 default:
364 break;
365 }
366 }
367 else if (base == uint_cls) {
368 switch (size) {
369 case 2:
370 return uint2_cls;
371 case 3:
372 return uint3_cls;
373 case 4:
374 return uint4_cls;
375 default:
376 break;
377 }
378 }
379 else if (base == bool_cls) {
380 switch (size) {
381 case 2:
382 return bool2_cls;
383 case 3:
384 return bool3_cls;
385 case 4:
386 return bool4_cls;
387 default:
388 break;
389 }
390 }
391 else if (base == half_cls) {
392 switch (size) {
393 case 2:
394 return half2_cls;
395 case 3:
396 return half3_cls;
397 case 4:
398 return half4_cls;
399 default:
400 break;
401 }
402 }
403 else if (base == char_cls) {
404 switch (size) {
405 case 2:
406 return char2_cls;
407 case 3:
408 return char3_cls;
409 case 4:
410 return char4_cls;
411 default:
412 break;
413 }
414 }
415 else if (base == uchar_cls) {
416 switch (size) {
417 case 2:
418 return uchar2_cls;
419 case 3:
420 return uchar3_cls;
421 case 4:
422 return uchar4_cls;
423 default:
424 break;
425 }
426 }
427 else if (base == short_cls) {
428 switch (size) {
429 case 2:
430 return short2_cls;
431 case 3:
432 return short3_cls;
433 case 4:
434 return short4_cls;
435 default:
436 break;
437 }
438 }
439 else if (base == ushort_cls) {
440 switch (size) {
441 case 2:
442 return ushort2_cls;
443 case 3:
444 return ushort3_cls;
445 case 4:
446 return ushort4_cls;
447 default:
448 break;
449 }
450 }
451 else if (base == float2_cls) {
452 switch (size) {
453 case 2:
454 return float2x2_cls;
455 case 3:
456 return float3x2_cls;
457 case 4:
458 return float4x2_cls;
459 default:
460 break;
461 }
462 }
463 else if (base == float3_cls) {
464 switch (size) {
465 case 2:
466 return float2x3_cls;
467 case 3:
468 return float3x3_cls;
469 case 4:
470 return float4x3_cls;
471 default:
472 break;
473 }
474 }
475 else if (base == float4_cls) {
476 switch (size) {
477 case 2:
478 return float2x4_cls;
479 case 3:
480 return float3x4_cls;
481 case 4:
482 return float4x4_cls;
483 default:
484 break;
485 }
486 }
487 return nullptr;
488}
489
490/* Generates all scalar and vector types (e.g. int, int2, int3, int4). */
491vector<SymbolTable::BuiltinType> SymbolTable::generate_builtin_types()
492{
493 vector<BuiltinType> types{
497
501
505
509 };
510 return types;
511}
512
513} // namespace bsl
ClassId binary_operator_return_type(SymbolClass *lhs, TokenType op, SymbolClass *rhs)
Definition operator.cc:102
ClassId unary_suffix_operator_return_type(SymbolClass *lhs, TokenType op)
Definition operator.cc:219
ClassId unary_prefix_operator_return_type(TokenType op, SymbolClass *rhs)
Definition operator.cc:193
Definition codegen.cc:18
OperatorType
Definition operator.cc:13
@ OP_RELATIONAL
Definition operator.cc:25
@ OP_EQUALITY
Definition operator.cc:24
@ OP_INVALID
Definition operator.cc:31
@ OP_ARITHMETIC
Definition operator.cc:21
@ OP_NUMERIC
Definition operator.cc:16
@ OP_BOOL
Definition operator.cc:18
@ OP_BITWISE
Definition operator.cc:22
@ OP_SHIFT
Definition operator.cc:23
@ OP_ASSIGN
Definition operator.cc:27
@ OP_LOGICAL
Definition operator.cc:26
@ OP_INTEGER
Definition operator.cc:17
static OperatorType to_operator_type(TokenType tok_type)
Definition operator.cc:34
TokenType
Definition types.hh:41
@ RShift
Definition types.hh:126
@ GThan
Definition types.hh:149
@ AssignSub
Definition types.hh:135
@ LThan
Definition types.hh:150
@ LogicalOr
Definition types.hh:93
@ Not
Definition types.hh:64
@ AssignAdd
Definition types.hh:133
@ Modulo
Definition types.hh:152
@ And
Definition types.hh:146
@ LogicalAnd
Definition types.hh:81
@ BitwiseNot
Definition types.hh:151
@ Multiply
Definition types.hh:145
@ AssignLShift
Definition types.hh:138
@ AssignRShift
Definition types.hh:139
@ LEqual
Definition types.hh:104
@ Plus
Definition types.hh:68
@ Decrement
Definition types.hh:88
@ Increment
Definition types.hh:112
@ AssignDiv
Definition types.hh:137
@ NotEqual
Definition types.hh:89
@ Equal
Definition types.hh:90
@ Divide
Definition types.hh:70
@ Xor
Definition types.hh:148
@ LShift
Definition types.hh:125
@ Assign
Definition types.hh:61
@ Minus
Definition types.hh:69
@ AssignMul
Definition types.hh:136
@ GEqual
Definition types.hh:94
@ Or
Definition types.hh:147
builtin::ClassId builtin_class
SymbolClass * half4_cls
SymbolClass * float3x2_cls
SymbolClass * float4_cls
SymbolClass * to_class(builtin::ClassId id) const
Definition operator.cc:238
SymbolClass * ushort_cls
SymbolClass * bool3_cls
SymbolClass * short4_cls
SymbolClass * float4x3_cls
SymbolClass * uchar2_cls
SymbolClass * uint4_cls
SymbolClass * uint3_cls
SymbolClass * float3x3_cls
SymbolClass * uchar3_cls
SymbolClass * int2_cls
SymbolClass * half3_cls
SymbolClass * short3_cls
SymbolClass * float2_cls
SymbolClass * float2x2_cls
SymbolClass * uchar4_cls
SymbolClass * uint_cls
SymbolClass * uint2_cls
SymbolClass * bool2_cls
SymbolClass * float2x3_cls
SymbolClass * float_cls
SymbolClass * bool_cls
SymbolClass * short_cls
SymbolClass * half2_cls
SymbolClass * float2x4_cls
SymbolClass * make_type(SymbolClass *base, int size) const
Definition operator.cc:336
SymbolClass * err_cls
SymbolClass * int3_cls
SymbolClass * float3x4_cls
SymbolClass * float4x2_cls
SymbolClass * float3_cls
SymbolClass * short2_cls
SymbolClass * int4_cls
SymbolClass * char2_cls
SymbolClass * uchar_cls
SymbolClass * int_cls
SymbolClass * ushort2_cls
SymbolClass * char_cls
SymbolClass * bool4_cls
SymbolClass * char3_cls
SymbolClass * half_cls
SymbolClass * ushort4_cls
SymbolClass * ushort3_cls
SymbolClass * float4x4_cls
SymbolClass * char4_cls