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 | 4525471 | TypeQualifiers TypeQualifiers::of(uint16_t superType) { | |
17 |
5/6✓ Branch 0 (2→3) taken 107346 times.
✓ Branch 1 (2→6) taken 258548 times.
✓ Branch 2 (2→9) taken 67689 times.
✓ Branch 3 (2→12) taken 1621 times.
✓ Branch 4 (2→15) taken 4090267 times.
✗ Branch 5 (2→18) not taken.
|
4525471 | switch (superType) { |
18 | 107346 | case TY_DOUBLE: // fall-through | |
19 | case TY_INT: // fall-through | ||
20 | case TY_SHORT: // fall-through | ||
21 | case TY_LONG: | ||
22 | 107346 | return {/*const*/ false, /*signed*/ true, /*unsigned*/ false}; | |
23 | 258548 | 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 | 258548 | return {/*const*/ false, /*signed*/ false, /*unsigned*/ true}; | |
35 | 67689 | case TY_GENERIC: | |
36 | // Generics must be non-signed and non-unsigned at the same time to ensure a proper function matching | ||
37 | 67689 | return {/*const*/ false, /*signed*/ false, /*unsigned*/ false}; | |
38 | 1621 | case TY_ENUM: // fall-through | |
39 | case TY_ALIAS: // fall-through | ||
40 | case TY_IMPORT: | ||
41 | 1621 | return {/*const*/ true, /*signed*/ false, /*unsigned*/ true}; | |
42 | 4090267 | 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 | 4090267 | 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 | 9944 | TypeQualifiers TypeQualifiers::merge(const TypeQualifiers &other) const { | |
59 | 9944 | TypeQualifiers result; | |
60 |
6/8✓ Branch 0 (2→3) taken 9944 times.
✗ Branch 1 (2→23) not taken.
✓ Branch 2 (3→4) taken 9601 times.
✓ Branch 3 (3→7) taken 343 times.
✓ Branch 4 (4→5) taken 9601 times.
✗ Branch 5 (4→23) not taken.
✓ Branch 6 (5→6) taken 8406 times.
✓ Branch 7 (5→7) taken 1195 times.
|
9944 | const bool isGeneric = !getBit(BIT_INDEX_SIGNED) && !getBit(BIT_INDEX_UNSIGNED); |
61 |
2/2✓ Branch 0 (20→9) taken 69608 times.
✓ Branch 1 (20→21) taken 9944 times.
|
79552 | for (uint8_t i = 0; i <= BIT_INDEX_MAX; i++) { |
62 |
1/2✓ Branch 0 (9→10) taken 69608 times.
✗ Branch 1 (9→23) not taken.
|
69608 | const bool x = getBit(i); |
63 |
1/2✓ Branch 0 (10→11) taken 69608 times.
✗ Branch 1 (10→23) not taken.
|
69608 | const bool y = other.getBit(i); |
64 | |||
65 |
4/4✓ Branch 0 (11→12) taken 59664 times.
✓ Branch 1 (11→13) taken 9944 times.
✓ Branch 2 (12→13) taken 9944 times.
✓ Branch 3 (12→18) taken 49720 times.
|
69608 | if (i == BIT_INDEX_SIGNED || i == BIT_INDEX_UNSIGNED) { |
66 |
3/4✓ Branch 0 (13→14) taken 16812 times.
✓ Branch 1 (13→15) taken 3076 times.
✓ Branch 2 (16→17) taken 19888 times.
✗ Branch 3 (16→23) not taken.
|
19888 | result.setBit(i, isGeneric ? y : x); |
67 | } else { | ||
68 |
1/2✓ Branch 0 (18→19) taken 49720 times.
✗ Branch 1 (18→23) not taken.
|
49720 | result.setBit(i, x | y); |
69 | } | ||
70 | } | ||
71 | 9944 | 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 | 10852 | bool TypeQualifiers::match(TypeQualifiers other, bool allowConstify) const { | |
82 | 10852 | 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 10847 times.
✓ Branch 1 (2→5) taken 5 times.
✓ Branch 2 (3→4) taken 1358 times.
✓ Branch 3 (3→5) taken 9489 times.
|
10852 | if (allowConstify && thisQualifiers.isConst) |
86 | 1358 | other.isConst = true; | |
87 | |||
88 | // Check if qualifiers are equal | ||
89 | 10852 | 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 | 4387 | 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 30709 times.
✓ Branch 1 (11→12) taken 4387 times.
|
35096 | for (uint8_t i = 0; i <= BIT_INDEX_MAX; i++) { |
100 |
2/2✓ Branch 0 (4→5) taken 987 times.
✓ Branch 1 (4→10) taken 29722 times.
|
30709 | if (mask.getBit(i)) { |
101 | // Zero out the bit | ||
102 | 987 | 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 987 times.
|
987 | if (i == BIT_INDEX_SIGNED) { |
106 | ✗ | setBit(BIT_INDEX_UNSIGNED, true); | |
107 |
2/2✓ Branch 0 (8→9) taken 205 times.
✓ Branch 1 (8→10) taken 782 times.
|
987 | } else if (i == BIT_INDEX_UNSIGNED) { |
108 | 205 | setBit(BIT_INDEX_SIGNED, true); | |
109 | } | ||
110 | } | ||
111 | } | ||
112 | 4387 | } | |
113 | |||
114 | 10949 | bool operator==(const TypeQualifiers &lhs, const TypeQualifiers &rhs) { | |
115 | 10949 | const bool isConst = lhs.isConst == rhs.isConst; | |
116 | 10949 | const bool isSigned = lhs.isSigned == rhs.isSigned; | |
117 | 10949 | const bool isUnsigned = lhs.isUnsigned == rhs.isUnsigned; | |
118 | 10949 | const bool isHeap = lhs.isHeap == rhs.isHeap; | |
119 |
6/8✓ Branch 0 (2→3) taken 10932 times.
✓ Branch 1 (2→7) taken 17 times.
✓ Branch 2 (3→4) taken 10932 times.
✗ Branch 3 (3→7) not taken.
✓ Branch 4 (4→5) taken 10932 times.
✗ Branch 5 (4→7) not taken.
✓ Branch 6 (5→6) taken 10836 times.
✓ Branch 7 (5→7) taken 96 times.
|
10949 | return isConst && isSigned && isUnsigned && isHeap; |
120 | } | ||
121 | |||
122 | 189470 | bool TypeQualifiers::getBit(uint8_t index) const { | |
123 |
7/8✓ Branch 0 (2→3) taken 24275 times.
✓ Branch 1 (2→4) taken 34219 times.
✓ Branch 2 (2→5) taken 33876 times.
✓ Branch 3 (2→6) taken 24275 times.
✓ Branch 4 (2→7) taken 24275 times.
✓ Branch 5 (2→8) taken 24275 times.
✓ Branch 6 (2→9) taken 24275 times.
✗ Branch 7 (2→10) not taken.
|
189470 | switch (index) { |
124 | 24275 | case BIT_INDEX_CONST: | |
125 | 24275 | return isConst; | |
126 | 34219 | case BIT_INDEX_SIGNED: | |
127 | 34219 | return isSigned; | |
128 | 33876 | case BIT_INDEX_UNSIGNED: | |
129 | 33876 | return isUnsigned; | |
130 | 24275 | case BIT_INDEX_HEAP: | |
131 | 24275 | return isHeap; | |
132 | 24275 | case BIT_INDEX_PUBLIC: | |
133 | 24275 | return isPublic; | |
134 | 24275 | case BIT_INDEX_INLINE: | |
135 | 24275 | return isInline; | |
136 | 24275 | case BIT_INDEX_COMPOSITION: | |
137 | 24275 | return isComposition; | |
138 | ✗ | default: | |
139 | − | throw CompilerError(UNHANDLED_BRANCH, "Bit index fallthrough"); // GCOV_EXCL_LINE | |
140 | } | ||
141 | } | ||
142 | |||
143 | 70800 | bool TypeQualifiers::setBit(uint8_t index, bool value) { | |
144 |
7/8✓ Branch 0 (2→3) taken 10726 times.
✓ Branch 1 (2→4) taken 10149 times.
✓ Branch 2 (2→5) taken 10149 times.
✓ Branch 3 (2→6) taken 9944 times.
✓ Branch 4 (2→7) taken 9944 times.
✓ Branch 5 (2→8) taken 9944 times.
✓ Branch 6 (2→9) taken 9944 times.
✗ Branch 7 (2→10) not taken.
|
70800 | switch (index) { |
145 | 10726 | case BIT_INDEX_CONST: | |
146 | 10726 | return isConst = value; | |
147 | 10149 | case BIT_INDEX_SIGNED: | |
148 | 10149 | return isSigned = value; | |
149 | 10149 | case BIT_INDEX_UNSIGNED: | |
150 | 10149 | return isUnsigned = value; | |
151 | 9944 | case BIT_INDEX_HEAP: | |
152 | 9944 | return isHeap = value; | |
153 | 9944 | case BIT_INDEX_PUBLIC: | |
154 | 9944 | return isPublic = value; | |
155 | 9944 | case BIT_INDEX_INLINE: | |
156 | 9944 | return isInline = value; | |
157 | 9944 | case BIT_INDEX_COMPOSITION: | |
158 | 9944 | return isComposition = value; | |
159 | ✗ | default: | |
160 | − | throw CompilerError(UNHANDLED_BRANCH, "Bit index fallthrough"); // GCOV_EXCL_LINE | |
161 | } | ||
162 | } | ||
163 | |||
164 | } // namespace spice::compiler | ||
165 |