Skip to content

Commit ad66595

Browse files
AjayBrahmakshatriyaAjayBrahmakshatriya
authored
Merge pull request #82 from AjayBrahmakshatriya/master
Extended builder::arrays to support any types and not just dyn_vars
2 parents ea71cf5 + aa1a8d9 commit ad66595

File tree

4 files changed

+126
-35
lines changed

4 files changed

+126
-35
lines changed

‎include/builder/array.h

Lines changed: 56 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -5,113 +5,134 @@
55

66
namespace builder {
77

8+
9+
// If the array is of dyn_vars, we initialize with a
10+
// builder, anything else and we directly initialize with T
11+
// This avoids unnecessary copies unless entirely necessary
12+
template <typename T>
13+
struct initializer_selector {
14+
typedef const T type;
15+
};
16+
17+
template <typename T>
18+
struct initializer_selector<dyn_var<T>> {
19+
typedef builder type;
20+
};
21+
22+
23+
824
template <typename T, size_t size = 0>
9-
class dyn_arr {
25+
class array {
1026
private:
11-
dyn_var<T> *m_arr = nullptr;
27+
T *m_arr = nullptr;
1228
size_t actual_size = 0;
1329

1430
public:
15-
dyn_arr() {
31+
array() {
1632
if (size) {
1733
actual_size = size;
18-
m_arr = (dyn_var<T> *)new char[sizeof(dyn_var<T>) * actual_size];
34+
m_arr = (T *)new char[sizeof(T) * actual_size];
1935
for (static_var<size_t> i = 0; i < actual_size; i++) {
20-
new (m_arr + i) dyn_var<T>();
36+
new (m_arr + i) T();
2137
}
38+
2239
// static tags for array nodes need to be adjusted
2340
// so they are treated different from each other despite
2441
// being declared at the same location.
2542
// dyn_arr are special case of vars that escape their static scope but still
2643
// shouldn't be treated together
2744
// We do this by adding additional metadata on all of them
28-
for (static_var<size_t> i = 0; i < actual_size; i++) {
29-
m_arr[i].block_var->template setMetadata<int>("allow_escape_scope", 1);
30-
}
45+
46+
// We are removing the metadata for allow_escape_scope because it is not being
47+
// used anyway right now. Enabling this would require us to set it as a variable
48+
// inside the context so all the dynamic variables constructed in this block would have
49+
// the metadata set
50+
3151
}
3252
}
33-
dyn_arr(const std::initializer_list<builder> &init) {
53+
// We need a SFINAE constructor of anything that is convertible to T
54+
// but let's stick with T for now
55+
array(const std::initializer_list<typename initializer_selector<T>::type> &init) {
3456
if (size) {
3557
actual_size = size;
3658
} else {
3759
actual_size = init.size();
3860
}
39-
m_arr = (dyn_var<T> *)new char[sizeof(dyn_var<T>) * actual_size];
61+
m_arr = (T *)new char[sizeof(T) * actual_size];
4062
for (static_var<size_t> i = 0; i < actual_size; i++) {
4163
if (i < init.size())
42-
new (m_arr + i) dyn_var<T>(*(init.begin() + i));
64+
new (m_arr + i) T(*(init.begin() + i));
4365
else
44-
new (m_arr + i) dyn_var<T>();
45-
}
46-
for (static_var<size_t> i = 0; i < actual_size; i++) {
47-
m_arr[i].block_var->template setMetadata<int>("allow_escape_scope", 1);
66+
new (m_arr + i) T();
4867
}
4968
}
69+
70+
5071
void set_size(size_t new_size) {
5172
assert(size == 0 && "set_size should be only called for dyn_arr without size");
5273
assert(m_arr == nullptr && "set_size should be only called once");
5374
actual_size = new_size;
54-
m_arr = (dyn_var<T> *)new char[sizeof(dyn_var<T>) * actual_size];
55-
for (static_var<size_t> i = 0; i < actual_size; i++) {
56-
new (m_arr + i) dyn_var<T>();
57-
}
75+
m_arr = (T *)new char[sizeof(T) * actual_size];
5876
for (static_var<size_t> i = 0; i < actual_size; i++) {
59-
m_arr[i].block_var->template setMetadata<int>("allow_escape_scope", 1);
77+
new (m_arr + i) T();
6078
}
6179
}
6280

6381
template <typename T2, size_t N>
64-
void initialize_from_other(const dyn_arr<T2, N> &other) {
82+
void initialize_from_other(const array<T2, N> &other) {
6583
if (size) {
6684
actual_size = size;
6785
} else {
6886
actual_size = other.actual_size;
6987
}
70-
m_arr = (dyn_var<T> *)new char[sizeof(dyn_var<T>) * actual_size];
88+
m_arr = (T*)new char[sizeof(T) * actual_size];
7189
for (static_var<size_t> i = 0; i < actual_size; i++) {
7290
if (i < other.actual_size)
73-
new (m_arr + i) dyn_var<T>(other[i]);
91+
new (m_arr + i) T(other[i]);
7492
else
75-
new (m_arr + i) dyn_var<T>();
76-
}
77-
for (static_var<size_t> i = 0; i < actual_size; i++) {
78-
m_arr[i].block_var->template setMetadata<int>("allow_escape_scope", 1);
93+
new (m_arr + i) T();
7994
}
8095
}
8196

82-
dyn_arr(const dyn_arr &other) {
97+
array(const array &other) {
8398
initialize_from_other(other);
8499
}
85100
template <typename T2, size_t N>
86-
dyn_arr(const dyn_arr<T2, N> &other) {
101+
array(const array<T2, N> &other) {
87102
initialize_from_other(other);
88103
}
89104

90-
dyn_arr &operator=(const dyn_arr &other) = delete;
105+
array &operator=(const array &other) = delete;
91106

92-
dyn_var<T> &operator[](size_t index) {
107+
T &operator[](size_t index) {
93108
assert(m_arr != nullptr && "Should call set_size for arrays that don't have a size");
94109
return m_arr[index];
95110
}
96-
const dyn_var<T> &operator[](size_t index) const {
111+
const T &operator[](size_t index) const {
97112
assert(m_arr != nullptr && "Should call set_size for arrays that don't have a size");
98113
return m_arr[index];
99114
}
100115

101-
~dyn_arr() {
116+
~array() {
102117
if (m_arr) {
103118
for (static_var<size_t> i = 0; i < actual_size; i++) {
104-
m_arr[i].~dyn_var<T>();
119+
m_arr[i].~T();
105120
}
106121

107122
delete[](char *) m_arr;
108123
}
109124
}
110125

111126
template <typename T2, size_t N>
112-
friend class dyn_arr;
127+
friend class array;
113128
};
114129

130+
template <typename T, size_t N = 0>
131+
using dyn_arr = array<dyn_var<T>, N>;
132+
133+
template <typename T, size_t N = 0>
134+
using arr = array<T, N>;
135+
115136
} // namespace builder
116137

117138
#endif

‎samples/outputs.var_names/sample43

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -22,5 +22,29 @@ void foo (void) {
2222
int var17;
2323
int var18;
2424
int var19;
25+
int var20;
26+
int* var21;
27+
var20 = 0;
28+
int var22;
29+
int* var23;
30+
var22 = 0;
31+
int var24;
32+
int* var25;
33+
var24 = 0;
34+
int var26;
35+
int* var27;
36+
var26 = 0;
37+
int var28;
38+
int* var29;
39+
var28 = 0;
40+
var21 = (&(var22));
41+
int var30 = var20;
42+
int* var31 = var21;
43+
int var32 = var22;
44+
int* var33 = var23;
45+
int var34 = var30;
46+
int* var35 = var31;
47+
int var36 = var32;
48+
int* var37 = var33;
2549
}
2650

‎samples/outputs/sample43

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -22,5 +22,29 @@ void foo (void) {
2222
int var17;
2323
int var18;
2424
int var19;
25+
int var20;
26+
int* var21;
27+
var20 = 0;
28+
int var22;
29+
int* var23;
30+
var22 = 0;
31+
int var24;
32+
int* var25;
33+
var24 = 0;
34+
int var26;
35+
int* var27;
36+
var26 = 0;
37+
int var28;
38+
int* var29;
39+
var28 = 0;
40+
var21 = (&(var22));
41+
int var30 = var20;
42+
int* var31 = var21;
43+
int var32 = var22;
44+
int* var33 = var23;
45+
int var34 = var30;
46+
int* var35 = var31;
47+
int var36 = var32;
48+
int* var37 = var33;
2549
}
2650

‎samples/sample43.cpp

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,8 +4,22 @@
44

55
using builder::dyn_arr;
66
using builder::dyn_var;
7+
using builder::arr;
8+
79
using namespace std;
810

11+
12+
13+
struct container {
14+
dyn_var<int> idx;
15+
dyn_var<int*> next;
16+
17+
container() {
18+
idx = 0;
19+
}
20+
};
21+
22+
923
static void foo() {
1024
dyn_arr<int, 3> x;
1125
x[0] = 1;
@@ -21,6 +35,14 @@ static void foo() {
2135

2236
dyn_arr<int> b = y;
2337
dyn_arr<int, 5> c = a;
38+
39+
40+
arr<container, 5> containers;
41+
containers[0].next = &(containers[1].idx);
42+
43+
44+
arr<container, 2> conts = {containers[0], containers[1]};
45+
2446
}
2547
int main(int argc, char *argv[]) {
2648
auto ast = builder::builder_context().extract_function_ast(foo, "foo");

0 commit comments

Comments
 (0)