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 | 4093517 | TypeQualifiers TypeQualifiers::of(uint16_t superType) { | |
17 |
5/6✓ Branch 0 (2→3) taken 110799 times.
✓ Branch 1 (2→6) taken 253001 times.
✓ Branch 2 (2→9) taken 59718 times.
✓ Branch 3 (2→12) taken 1460 times.
✓ Branch 4 (2→15) taken 3668539 times.
✗ Branch 5 (2→18) not taken.
|
4093517 | switch (superType) { |
18 | 110799 | case TY_DOUBLE: // fall-through | |
19 | case TY_INT: // fall-through | ||
20 | case TY_SHORT: // fall-through | ||
21 | case TY_LONG: | ||
22 | 110799 | return {/*const*/ false, /*signed*/ true, /*unsigned*/ false}; | |
23 | 253001 | 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 | 253001 | return {/*const*/ false, /*signed*/ false, /*unsigned*/ true}; | |
35 | 59718 | case TY_GENERIC: | |
36 | // Generics must be non-signed and non-unsigned at the same time to ensure a proper function matching | ||
37 | 59718 | return {/*const*/ false, /*signed*/ false, /*unsigned*/ false}; | |
38 | 1460 | case TY_ENUM: // fall-through | |
39 | case TY_ALIAS: // fall-through | ||
40 | case TY_IMPORT: | ||
41 | 1460 | return {/*const*/ true, /*signed*/ false, /*unsigned*/ true}; | |
42 | 3668539 | 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 | 3668539 | 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 | 12778 | TypeQualifiers TypeQualifiers::merge(const TypeQualifiers &other) const { | |
59 | 12778 | TypeQualifiers result; | |
60 |
6/8✓ Branch 0 (2→3) taken 12778 times.
✗ Branch 1 (2→23) not taken.
✓ Branch 2 (3→4) taken 12425 times.
✓ Branch 3 (3→7) taken 353 times.
✓ Branch 4 (4→5) taken 12425 times.
✗ Branch 5 (4→23) not taken.
✓ Branch 6 (5→6) taken 8056 times.
✓ Branch 7 (5→7) taken 4369 times.
|
12778 | const bool isGeneric = !getBit(BIT_INDEX_SIGNED) && !getBit(BIT_INDEX_UNSIGNED); |
61 |
2/2✓ Branch 0 (20→9) taken 89446 times.
✓ Branch 1 (20→21) taken 12778 times.
|
102224 | for (uint8_t i = 0; i <= BIT_INDEX_MAX; i++) { |
62 |
1/2✓ Branch 0 (9→10) taken 89446 times.
✗ Branch 1 (9→23) not taken.
|
89446 | const bool x = getBit(i); |
63 |
1/2✓ Branch 0 (10→11) taken 89446 times.
✗ Branch 1 (10→23) not taken.
|
89446 | const bool y = other.getBit(i); |
64 | |||
65 |
4/4✓ Branch 0 (11→12) taken 76668 times.
✓ Branch 1 (11→13) taken 12778 times.
✓ Branch 2 (12→13) taken 12778 times.
✓ Branch 3 (12→18) taken 63890 times.
|
89446 | if (i == BIT_INDEX_SIGNED || i == BIT_INDEX_UNSIGNED) { |
66 |
3/4✓ Branch 0 (13→14) taken 16112 times.
✓ Branch 1 (13→15) taken 9444 times.
✓ Branch 2 (16→17) taken 25556 times.
✗ Branch 3 (16→23) not taken.
|
25556 | result.setBit(i, isGeneric ? y : x); |
67 | } else { | ||
68 |
1/2✓ Branch 0 (18→19) taken 63890 times.
✗ Branch 1 (18→23) not taken.
|
63890 | result.setBit(i, x | y); |
69 | } | ||
70 | } | ||
71 | 12778 | 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 | 10433 | bool TypeQualifiers::match(TypeQualifiers other, bool allowConstify) const { | |
82 | 10433 | 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 10413 times.
✓ Branch 1 (2→5) taken 20 times.
✓ Branch 2 (3→4) taken 1330 times.
✓ Branch 3 (3→5) taken 9083 times.
|
10433 | if (allowConstify && thisQualifiers.isConst) |
86 | 1330 | other.isConst = true; | |
87 | |||
88 | // Check if qualifiers are equal | ||
89 | 10433 | 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 | 4135 | 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 28945 times.
✓ Branch 1 (11→12) taken 4135 times.
|
33080 | for (uint8_t i = 0; i <= BIT_INDEX_MAX; i++) { |
100 |
2/2✓ Branch 0 (4→5) taken 943 times.
✓ Branch 1 (4→10) taken 28002 times.
|
28945 | if (mask.getBit(i)) { |
101 | // Zero out the bit | ||
102 | 943 | 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 943 times.
|
943 | if (i == BIT_INDEX_SIGNED) { |
106 | ✗ | setBit(BIT_INDEX_UNSIGNED, true); | |
107 |
2/2✓ Branch 0 (8→9) taken 179 times.
✓ Branch 1 (8→10) taken 764 times.
|
943 | } else if (i == BIT_INDEX_UNSIGNED) { |
108 | 179 | setBit(BIT_INDEX_SIGNED, true); | |
109 | } | ||
110 | } | ||
111 | } | ||
112 | 4135 | } | |
113 | |||
114 | 10522 | bool operator==(const TypeQualifiers &lhs, const TypeQualifiers &rhs) { | |
115 | 10522 | const bool isConst = lhs.isConst == rhs.isConst; | |
116 | 10522 | const bool isSigned = lhs.isSigned == rhs.isSigned; | |
117 | 10522 | const bool isUnsigned = lhs.isUnsigned == rhs.isUnsigned; | |
118 | 10522 | const bool isHeap = lhs.isHeap == rhs.isHeap; | |
119 |
6/8✓ Branch 0 (2→3) taken 10507 times.
✓ Branch 1 (2→7) taken 15 times.
✓ Branch 2 (3→4) taken 10507 times.
✗ Branch 3 (3→7) not taken.
✓ Branch 4 (4→5) taken 10507 times.
✗ Branch 5 (4→7) not taken.
✓ Branch 6 (5→6) taken 10419 times.
✓ Branch 7 (5→7) taken 88 times.
|
10522 | return isConst && isSigned && isUnsigned && isHeap; |
120 | } | ||
121 | |||
122 | 233040 | bool TypeQualifiers::getBit(uint8_t index) const { | |
123 |
7/8✓ Branch 0 (2→3) taken 29691 times.
✓ Branch 1 (2→4) taken 42469 times.
✓ Branch 2 (2→5) taken 42116 times.
✓ Branch 3 (2→6) taken 29691 times.
✓ Branch 4 (2→7) taken 29691 times.
✓ Branch 5 (2→8) taken 29691 times.
✓ Branch 6 (2→9) taken 29691 times.
✗ Branch 7 (2→10) not taken.
|
233040 | switch (index) { |
124 | 29691 | case BIT_INDEX_CONST: | |
125 | 29691 | return isConst; | |
126 | 42469 | case BIT_INDEX_SIGNED: | |
127 | 42469 | return isSigned; | |
128 | 42116 | case BIT_INDEX_UNSIGNED: | |
129 | 42116 | return isUnsigned; | |
130 | 29691 | case BIT_INDEX_HEAP: | |
131 | 29691 | return isHeap; | |
132 | 29691 | case BIT_INDEX_PUBLIC: | |
133 | 29691 | return isPublic; | |
134 | 29691 | case BIT_INDEX_INLINE: | |
135 | 29691 | return isInline; | |
136 | 29691 | case BIT_INDEX_COMPOSITION: | |
137 | 29691 | return isComposition; | |
138 | ✗ | default: | |
139 | − | throw CompilerError(UNHANDLED_BRANCH, "Bit index fallthrough"); // GCOV_EXCL_LINE | |
140 | } | ||
141 | } | ||
142 | |||
143 | 90568 | bool TypeQualifiers::setBit(uint8_t index, bool value) { | |
144 |
7/8✓ Branch 0 (2→3) taken 13542 times.
✓ Branch 1 (2→4) taken 12957 times.
✓ Branch 2 (2→5) taken 12957 times.
✓ Branch 3 (2→6) taken 12778 times.
✓ Branch 4 (2→7) taken 12778 times.
✓ Branch 5 (2→8) taken 12778 times.
✓ Branch 6 (2→9) taken 12778 times.
✗ Branch 7 (2→10) not taken.
|
90568 | switch (index) { |
145 | 13542 | case BIT_INDEX_CONST: | |
146 | 13542 | return isConst = value; | |
147 | 12957 | case BIT_INDEX_SIGNED: | |
148 | 12957 | return isSigned = value; | |
149 | 12957 | case BIT_INDEX_UNSIGNED: | |
150 | 12957 | return isUnsigned = value; | |
151 | 12778 | case BIT_INDEX_HEAP: | |
152 | 12778 | return isHeap = value; | |
153 | 12778 | case BIT_INDEX_PUBLIC: | |
154 | 12778 | return isPublic = value; | |
155 | 12778 | case BIT_INDEX_INLINE: | |
156 | 12778 | return isInline = value; | |
157 | 12778 | case BIT_INDEX_COMPOSITION: | |
158 | 12778 | return isComposition = value; | |
159 | ✗ | default: | |
160 | − | throw CompilerError(UNHANDLED_BRANCH, "Bit index fallthrough"); // GCOV_EXCL_LINE | |
161 | } | ||
162 | } | ||
163 | |||
164 | } // namespace spice::compiler | ||
165 |