Line | Branch | Exec | Source |
---|---|---|---|
1 | // Copyright (c) 2021-2025 ChilliBits. All rights reserved. | ||
2 | |||
3 | #include "TypeQualifiers.h" | ||
4 | |||
5 | #include <exception/CompilerError.h> | ||
6 | #include <symboltablebuilder/TypeChain.h> | ||
7 | |||
8 | namespace spice::compiler { | ||
9 | |||
10 | /** | ||
11 | * Get default type qualifiers for a given super type | ||
12 | * | ||
13 | * @param superType Super type | ||
14 | * @return Default type qualifiers | ||
15 | */ | ||
16 | 4725318 | TypeQualifiers TypeQualifiers::of(uint16_t superType) { | |
17 |
5/6✓ Branch 0 (2→3) taken 118535 times.
✓ Branch 1 (2→6) taken 275783 times.
✓ Branch 2 (2→9) taken 68664 times.
✓ Branch 3 (2→12) taken 1677 times.
✓ Branch 4 (2→15) taken 4260659 times.
✗ Branch 5 (2→18) not taken.
|
4725318 | switch (superType) { |
18 | 118535 | case TY_DOUBLE: // fall-through | |
19 | case TY_INT: // fall-through | ||
20 | case TY_SHORT: // fall-through | ||
21 | case TY_LONG: | ||
22 | 118535 | return {/*const*/ false, /*signed*/ true, /*unsigned*/ false}; | |
23 | 275783 | case TY_BYTE: // fall-through | |
24 | case TY_CHAR: // fall-through | ||
25 | case TY_STRING: // fall-through | ||
26 | case TY_BOOL: // fall-through | ||
27 | case TY_PTR: // fall-through | ||
28 | case TY_REF: // fall-through | ||
29 | case TY_ARRAY: // fall-through | ||
30 | case TY_STRUCT: // fall-through | ||
31 | case TY_INTERFACE: // fall-through | ||
32 | case TY_FUNCTION: // fall-through | ||
33 | case TY_PROCEDURE: | ||
34 | 275783 | return {/*const*/ false, /*signed*/ false, /*unsigned*/ true}; | |
35 | 68664 | case TY_GENERIC: | |
36 | // Generics must be non-signed and non-unsigned at the same time to ensure a proper function matching | ||
37 | 68664 | return {/*const*/ false, /*signed*/ false, /*unsigned*/ false}; | |
38 | 1677 | case TY_ENUM: // fall-through | |
39 | case TY_ALIAS: // fall-through | ||
40 | case TY_IMPORT: | ||
41 | 1677 | return {/*const*/ true, /*signed*/ false, /*unsigned*/ true}; | |
42 | 4260659 | case TY_DYN: // fall-through | |
43 | case TY_INVALID: // fall-through | ||
44 | case TY_UNRESOLVED: | ||
45 | // Return all-false qualifiers to not match anything | ||
46 | 4260659 | return {/*const*/ false, /*signed*/ false, /*unsigned*/ false}; | |
47 | ✗ | default: | |
48 | − | throw CompilerError(UNHANDLED_BRANCH, "Symbol qualifier fallthrough"); // GCOV_EXCL_LINE | |
49 | } | ||
50 | } | ||
51 | |||
52 | /** | ||
53 | * Merge two sets of type qualifiers. If possible, prefer the opposite of the default of the super type | ||
54 | * | ||
55 | * @param other Other type qualifiers object | ||
56 | * @return Merged qualifiers object | ||
57 | */ | ||
58 | 10066 | TypeQualifiers TypeQualifiers::merge(const TypeQualifiers &other) const { | |
59 | 10066 | TypeQualifiers result; | |
60 |
6/8✓ Branch 0 (2→3) taken 10066 times.
✗ Branch 1 (2→23) not taken.
✓ Branch 2 (3→4) taken 9723 times.
✓ Branch 3 (3→7) taken 343 times.
✓ Branch 4 (4→5) taken 9723 times.
✗ Branch 5 (4→23) not taken.
✓ Branch 6 (5→6) taken 8495 times.
✓ Branch 7 (5→7) taken 1228 times.
|
10066 | const bool isGeneric = !getBit(BIT_INDEX_SIGNED) && !getBit(BIT_INDEX_UNSIGNED); |
61 |
2/2✓ Branch 0 (20→9) taken 70462 times.
✓ Branch 1 (20→21) taken 10066 times.
|
80528 | for (uint8_t i = 0; i <= BIT_INDEX_MAX; i++) { |
62 |
1/2✓ Branch 0 (9→10) taken 70462 times.
✗ Branch 1 (9→23) not taken.
|
70462 | const bool x = getBit(i); |
63 |
1/2✓ Branch 0 (10→11) taken 70462 times.
✗ Branch 1 (10→23) not taken.
|
70462 | const bool y = other.getBit(i); |
64 | |||
65 |
4/4✓ Branch 0 (11→12) taken 60396 times.
✓ Branch 1 (11→13) taken 10066 times.
✓ Branch 2 (12→13) taken 10066 times.
✓ Branch 3 (12→18) taken 50330 times.
|
70462 | if (i == BIT_INDEX_SIGNED || i == BIT_INDEX_UNSIGNED) { |
66 |
3/4✓ Branch 0 (13→14) taken 16990 times.
✓ Branch 1 (13→15) taken 3142 times.
✓ Branch 2 (16→17) taken 20132 times.
✗ Branch 3 (16→23) not taken.
|
20132 | result.setBit(i, isGeneric ? y : x); |
67 | } else { | ||
68 |
1/2✓ Branch 0 (18→19) taken 50330 times.
✗ Branch 1 (18→23) not taken.
|
50330 | result.setBit(i, x | y); |
69 | } | ||
70 | } | ||
71 | 10066 | return result; | |
72 | } | ||
73 | |||
74 | /** | ||
75 | * Check if two sets of type qualifiers match | ||
76 | * | ||
77 | * @param other The rhs qualifiers | ||
78 | * @param allowConstify Match when the types are the same, but the lhs type is more const restrictive than the rhs type | ||
79 | * @return Matching or not | ||
80 | */ | ||
81 | 11123 | bool TypeQualifiers::match(TypeQualifiers other, bool allowConstify) const { | |
82 | 11123 | const TypeQualifiers thisQualifiers = *this; | |
83 | |||
84 | // If allowConstify is enabled, only allow to match lhs=const and rhs=non-const | ||
85 |
4/4✓ Branch 0 (2→3) taken 11118 times.
✓ Branch 1 (2→5) taken 5 times.
✓ Branch 2 (3→4) taken 1361 times.
✓ Branch 3 (3→5) taken 9757 times.
|
11123 | if (allowConstify && thisQualifiers.isConst) |
86 | 1361 | other.isConst = true; | |
87 | |||
88 | // Check if qualifiers are equal | ||
89 | 11123 | return thisQualifiers == other; | |
90 | } | ||
91 | |||
92 | /** | ||
93 | * Erase all qualifiers that are set in the mask. This is used in type matching. | ||
94 | * | ||
95 | * @param mask Bitmask to erase with | ||
96 | */ | ||
97 | 4429 | void TypeQualifiers::eraseWithMask(const TypeQualifiers &mask) { | |
98 | // Zero out all bits that are set in the mask | ||
99 |
2/2✓ Branch 0 (11→3) taken 31003 times.
✓ Branch 1 (11→12) taken 4429 times.
|
35432 | for (uint8_t i = 0; i <= BIT_INDEX_MAX; i++) { |
100 |
2/2✓ Branch 0 (4→5) taken 1010 times.
✓ Branch 1 (4→10) taken 29993 times.
|
31003 | if (mask.getBit(i)) { |
101 | // Zero out the bit | ||
102 | 1010 | setBit(i, false); | |
103 | |||
104 | // If we set the signed/unsigned bit to zero, we need to set the other to one | ||
105 |
1/2✗ Branch 0 (6→7) not taken.
✓ Branch 1 (6→8) taken 1010 times.
|
1010 | if (i == BIT_INDEX_SIGNED) { |
106 | ✗ | setBit(BIT_INDEX_UNSIGNED, true); | |
107 |
2/2✓ Branch 0 (8→9) taken 208 times.
✓ Branch 1 (8→10) taken 802 times.
|
1010 | } else if (i == BIT_INDEX_UNSIGNED) { |
108 | 208 | setBit(BIT_INDEX_SIGNED, true); | |
109 | } | ||
110 | } | ||
111 | } | ||
112 | 4429 | } | |
113 | |||
114 | 11220 | bool operator==(const TypeQualifiers &lhs, const TypeQualifiers &rhs) { | |
115 | 11220 | const bool isConst = lhs.isConst == rhs.isConst; | |
116 | 11220 | const bool isSigned = lhs.isSigned == rhs.isSigned; | |
117 | 11220 | const bool isUnsigned = lhs.isUnsigned == rhs.isUnsigned; | |
118 | 11220 | const bool isHeap = lhs.isHeap == rhs.isHeap; | |
119 |
6/8✓ Branch 0 (2→3) taken 11203 times.
✓ Branch 1 (2→7) taken 17 times.
✓ Branch 2 (3→4) taken 11203 times.
✗ Branch 3 (3→7) not taken.
✓ Branch 4 (4→5) taken 11203 times.
✗ Branch 5 (4→7) not taken.
✓ Branch 6 (5→6) taken 11107 times.
✓ Branch 7 (5→7) taken 96 times.
|
11220 | return isConst && isSigned && isUnsigned && isHeap; |
120 | } | ||
121 | |||
122 | 191716 | bool TypeQualifiers::getBit(uint8_t index) const { | |
123 |
7/8✓ Branch 0 (2→3) taken 24561 times.
✓ Branch 1 (2→4) taken 34627 times.
✓ Branch 2 (2→5) taken 34284 times.
✓ Branch 3 (2→6) taken 24561 times.
✓ Branch 4 (2→7) taken 24561 times.
✓ Branch 5 (2→8) taken 24561 times.
✓ Branch 6 (2→9) taken 24561 times.
✗ Branch 7 (2→10) not taken.
|
191716 | switch (index) { |
124 | 24561 | case BIT_INDEX_CONST: | |
125 | 24561 | return isConst; | |
126 | 34627 | case BIT_INDEX_SIGNED: | |
127 | 34627 | return isSigned; | |
128 | 34284 | case BIT_INDEX_UNSIGNED: | |
129 | 34284 | return isUnsigned; | |
130 | 24561 | case BIT_INDEX_HEAP: | |
131 | 24561 | return isHeap; | |
132 | 24561 | case BIT_INDEX_PUBLIC: | |
133 | 24561 | return isPublic; | |
134 | 24561 | case BIT_INDEX_INLINE: | |
135 | 24561 | return isInline; | |
136 | 24561 | case BIT_INDEX_COMPOSITION: | |
137 | 24561 | return isComposition; | |
138 | ✗ | default: | |
139 | − | throw CompilerError(UNHANDLED_BRANCH, "Bit index fallthrough"); // GCOV_EXCL_LINE | |
140 | } | ||
141 | } | ||
142 | |||
143 | 71680 | bool TypeQualifiers::setBit(uint8_t index, bool value) { | |
144 |
7/8✓ Branch 0 (2→3) taken 10868 times.
✓ Branch 1 (2→4) taken 10274 times.
✓ Branch 2 (2→5) taken 10274 times.
✓ Branch 3 (2→6) taken 10066 times.
✓ Branch 4 (2→7) taken 10066 times.
✓ Branch 5 (2→8) taken 10066 times.
✓ Branch 6 (2→9) taken 10066 times.
✗ Branch 7 (2→10) not taken.
|
71680 | switch (index) { |
145 | 10868 | case BIT_INDEX_CONST: | |
146 | 10868 | return isConst = value; | |
147 | 10274 | case BIT_INDEX_SIGNED: | |
148 | 10274 | return isSigned = value; | |
149 | 10274 | case BIT_INDEX_UNSIGNED: | |
150 | 10274 | return isUnsigned = value; | |
151 | 10066 | case BIT_INDEX_HEAP: | |
152 | 10066 | return isHeap = value; | |
153 | 10066 | case BIT_INDEX_PUBLIC: | |
154 | 10066 | return isPublic = value; | |
155 | 10066 | case BIT_INDEX_INLINE: | |
156 | 10066 | return isInline = value; | |
157 | 10066 | case BIT_INDEX_COMPOSITION: | |
158 | 10066 | return isComposition = value; | |
159 | ✗ | default: | |
160 | − | throw CompilerError(UNHANDLED_BRANCH, "Bit index fallthrough"); // GCOV_EXCL_LINE | |
161 | } | ||
162 | } | ||
163 | |||
164 | } // namespace spice::compiler | ||
165 |