Added basic support for static_var arrays

Author: AjayBrahmakshatriya

include/builder/static_var.h

@@ -55,5 +55,67 @@ class static_var {
 	}
 };
 
+template <typename T>
+class static_var<T[]> {
+	public: 
+	static_assert(std::is_same<T, short int>::value || std::is_same<T, unsigned short int>::value ||
+			  std::is_same<T, int>::value || std::is_same<T, unsigned int>::value ||
+			  std::is_same<T, long int>::value || std::is_same<T, unsigned long int>::value ||
+			  std::is_same<T, long long int>::value || std::is_same<T, unsigned long long int>::value ||
+			  std::is_same<T, char>::value || std::is_same<T, unsigned char>::value ||
+			  std::is_same<T, float>::value || std::is_same<T, double>::value || std::is_pointer<T>::value,
+		      "Currently builder::static_var arrays is only supported for basic types\n");
+	static_assert(sizeof(T) < MAX_TRACKING_VAR_SIZE, "Currently builder::static_var supports variables of max size "
+							 "= " TOSTRING(MAX_TRACKING_VARIABLE_SIZE));
+	// Disable copy-assignment and initialization
+	static_var(const static_var& x) = delete;	
+	static_var& operator= (const static_var& x) = delete;
+	T* val = nullptr;
+	
+	T& operator[] (size_t index) {
+		return val[index];
+	}
+	const T& operator[] (size_t index) const {
+		return val[index];
+	}
+	static_var() {
+		assert(builder_context::current_builder_context != nullptr);
+		// This val _should_ not be used. But we will insert it to hold place
+		// for this static var in the list of tuples, otherwise destructor order will be weird
+		val = new T[1];
+		
+		builder_context::current_builder_context->static_var_tuples.push_back(
+		    tracking_tuple((unsigned char*)val, 1));
+	}
+	static_var(const std::initializer_list<T> &list) {
+		assert(builder_context::current_builder_context != nullptr);
+		val = new T[list.size()];
+		builder_context::current_builder_context->static_var_tuples.push_back(
+		    tracking_tuple((unsigned char*)val, sizeof(T) * list.size()));
+		for (int i = 0; i < list.size(); i++) {
+			val[i] = list[i];
+		}
+	}
+	void resize(size_t s) {
+		T* new_ptr = new T[s];
+		assert(builder_context::current_builder_context != nullptr);
+		assert(builder_context::current_builder_context->static_var_tuples.size() > 0);
+		for (size_t i = 0; i < builder_context::current_builder_context->static_var_tuples.size(); i++) {
+			if (builder_context::current_builder_context->static_var_tuples[i].ptr == (unsigned char*)val) {
+				builder_context::current_builder_context->static_var_tuples[i] = tracking_tuple((unsigned char*)new_ptr, sizeof(T) * s);
+				break;
+			}
+		}
+		delete[] val;
+		val = new_ptr;
+	}
+	~static_var() {
+		assert(builder_context::current_builder_context != nullptr);
+		assert(builder_context::current_builder_context->static_var_tuples.size() > 0);
+		assert(builder_context::current_builder_context->static_var_tuples.back().ptr == (unsigned char *)val);
+		builder_context::current_builder_context->static_var_tuples.pop_back();
+		delete[] val;	
+	}
+};
 } // namespace builder
 #endif

samples/sample47.cpp

@@ -0,0 +1,28 @@
+#include "builder/static_var.h"
+#include "builder/dyn_var.h"
+#include "blocks/c_code_generator.h"
+
+using builder::dyn_var;
+using builder::static_var;
+
+static void foo(void) {
+	static_var<int[]> states;
+	states.resize(4);
+	for (states[0] = 0; states[0] < 2; states[0]++) {
+		for (states[1] = 0; states[1] < 2; states[1]++) {
+			for (states[2] = 0; states[2] < 2; states[2]++) {
+				for (states[3] = 0; states[3] < 2; states[3]++) {
+					dyn_var<int> c = 0;	
+				}
+			}
+		}
+	}
+}
+int main(int argc, char *argv[]) {
+	builder::builder_context context;
+	auto ast = context.extract_function_ast(foo, "my_bar");
+	ast->dump(std::cout, 0);
+
+	block::c_code_generator::generate_code(ast, std::cout, 0);
+	return 0;
+}