start: return values

include/frame.h

@@ -34,6 +34,8 @@ struct _sm_user_page {
 
 struct _sm_frame {
 	uint64_t pc;
+
+	_sm_user* rval; // Pointer to the return value of this function 
 	_sm_user_page user;
 
 	_sm_frame* prev;

include/gen.h

@@ -4,6 +4,34 @@
 
 typedef sm_yield (*sm_gen_fun)(sm_state* state); //NOTE: Same as sm_yield
 
+typedef _sm_user sm_output;
+
+void sm_free_output(sm_output* data);
+
+template<typename T>
+inline const T* sm_output_ptr(const sm_output& data)
+{
+	if(data.set)
+		return _sm_get<T>(const_cast<_sm_user*>(&data));
+	else return nullptr;
+}
+
+template<typename T>
+inline bool sm_output_value(const sm_output& data, T* output)
+{
+	auto ptr = sm_output_ptr<T>(data);
+	if(ptr) {
+		*output = *ptr;
+		return true;
+	} else return false;
+}
+
+template<typename T>
+inline T sm_output_assume_value(const sm_output& data)
+{
+	return *sm_output_ptr<T>(data);
+}
+
 // A generator method
 struct sm_generator;
 
@@ -13,4 +41,5 @@ sm_generator* sm_generate(sm_gen_fun function);
 void sm_free_generator(sm_generator* generator);
 /// Run this generator until the next yield.
 /// Returns false if the generator ends.
-bool sm_next(sm_generator** gen, sm_state* state);
+/// Any output value yielded from the generator is returned in the output pointer, unless the pointer is NULL, in which case the output is discarded.
+bool sm_next(sm_generator** gen, sm_state* state, sm_output* output);

include/state.h

@@ -15,6 +15,29 @@ inline uint64_t _sm_compute_key(uint64_t name)
 	return _sm_confine_key(name);
 }
 
+template<typename T>
+inline T* _sm_replace(_sm_user* frame, T value)
+{
+	if(frame->set) _sm_free(frame);
+
+	frame->set = true;
+	frame->free = false;
+
+	// Key is left the same
+
+	return _sm_init(frame, value);
+}
+
+template<typename T>
+inline T* _sm_replace_ip(_sm_user** frame, T value)
+{
+
+	if(! (*frame)) {
+		*frame = box<_sm_user, true>();
+	}
+	return _sm_replace(*frame, value);	
+}
+
 template<typename T, typename U>
 inline T* _sm_var(_sm_user_page* user, U name, T init)
 {
@@ -76,6 +99,7 @@ inline sm_yield sm_continue() { return (sm_yield)_sm_noop; }
 #define SM_END } return sm_end()
 
 #define SM_YIELD(v) do { state->current->pc = __LINE__; return (sm_yield)(v); case __LINE__:; } while(0)
+#define SM_YIELD_VALUE(v) do { _sm_replace_ip(&state->current->rval, (v)); SM_YIELD(sm_continue()); } while(0)
 
 #define SM_GENERATOR(name) sm_yield name(sm_state* state)
 

src/gen.cpp

@@ -22,11 +22,16 @@ void sm_free_generator(sm_generator* gen)
 }
 
 // Returns false if the generator ends.
-bool sm_next(sm_generator** gen, sm_state* state)
+bool sm_next(sm_generator** gen, sm_state* state, _sm_user* output)
 {
 	if( !(*gen)->current) return false;
 
 	sm_yield next = (*gen)->current(state);
+
+	// Set the return value to `output`.
+	if(output && state->current->rval) *output = *state->current->rval;
+	else if(output) output->set = false;
+
 	switch((uintptr_t)next)
 	{
 		case 0:

src/main.cpp

@@ -7,21 +7,21 @@ struct _test {
 	int a, b;
 };
 
-sm_yield sm_test_2(sm_state* state)
+SM_GENERATOR(sm_test_2)
 {
 	int* a = SM_VAR(-10);
 
 	SM_BEGIN;
 		while( (*a) < 0 ) {
 			printf("(2) a = %d\n", *a);
-			SM_YIELD(sm_continue());
+			SM_YIELD_VALUE(*a);
 			(*a)+=1;
 		}
 		printf("Done!\n");
 	SM_END;
 }
 
-sm_yield sm_test(sm_state* state)
+SM_GENERATOR(sm_test)
 {
 	int* a = SM_VAR(10);
 
@@ -33,25 +33,32 @@ sm_yield sm_test(sm_state* state)
 
 	SM_BEGIN;
 		*a = 5;
-		SM_YIELD(sm_continue());
+		SM_YIELD_VALUE(*a);
-		printf("a = %d\n", *a);
+		printf("IN a = %d\n", *a);
-		*a = 0;
+		*a = 1;
-		SM_YIELD(sm_continue());
+		SM_YIELD_VALUE(*a);
-		printf("a = %d\n", *a);
+		printf("IN a = %d\n", *a);
-		printf("Starting function 2\n");
+		//printf("Starting function 2\n");
 		SM_YIELD(sm_test_2);
-		printf("2 done\n");
+		//printf("2 done\n");
+
 	SM_END;
 }
 
 int main()
 {
-
 	auto state = sm_new_state();
 	auto gen = sm_generate(&sm_test);
 
-	while(sm_next(&gen, state)) (void)0;
+	sm_output output;
+	while(sm_next(&gen, state, &output)) {
+		int out_int;
+		if(!sm_output_value(output, &out_int))
+			continue;
+		printf("OUT \t\ta = %d\n", out_int);
+	}
 
+	sm_free_output(&output);
 	sm_free_generator(gen);
 	sm_free_state(state);
 

src/state.cpp

@@ -23,6 +23,16 @@ inline static void sm_free_user(_sm_user* data)
 	}
 }
 
+void sm_free_output(_sm_user* data)
+{
+	if(!data) return;
+
+	if(data->set)
+		sm_free_user(data);
+	data->set = data->free = false;
+
+}
+
 inline static void _sm_free_page(_sm_user_page* page)
 {
 	for (int i=0;i<_SM_STACK_SIZE;i++) sm_free_user(&page->data[i]);
@@ -45,6 +55,11 @@ void sm_free_state(sm_state* state)
 
 	while(frame)
 	{
+		if(frame->rval) {
+			sm_free_user(frame->rval);
+			unbox(frame->rval);
+		}
+
 		_sm_free_all_pages(frame->user.next);
 		_sm_free_page(&frame->user);