Mercurial > repos > rhope

diff runtime/func.h @ 56:d2f9b0a9403d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial experiment with goto and switch
author Mike Pavone <pavone@retrodev.com>
date Thu, 08 Oct 2009 01:52:38 -0400
parents 3498713c3dc9
children 2174878a6e4b
line wrap: on
line diff
--- a/runtime/func.h	Tue Oct 06 23:13:47 2009 -0400
+++ b/runtime/func.h	Thu Oct 08 01:52:38 2009 -0400
@@ -15,183 +15,134 @@
 
 #define MethodName(name,type) f_ ## name ## _AT_ ## type
 
-#define Func(name,numparams,callspace,localtype) \
-	returntype f_ ## name (calldata * cdata)\
-	{\
-		localtype *locals;\
-		calldata *call;\
-		returntype ret;\
-		int idx;\
-		if(cdata->resume)\
-		{\
-			call = cdata->call;\
-			locals = cdata->locals;\
-		}\
-		switch(cdata->resume)\
+
+#define Func(name,numparams) \
+	case FUNC_ ## name:\
+f_ ## name:\
+		switch(resume)\
 		{\
 		case 0:\
 			for(idx = numparams; idx < cdata->num_params; ++idx)\
-				release_ref(cdata->params[idx]); cdata->num_params = numparams;\
-			cdata->num_params = numparams;\
-			cdata->call = call = alloc_cdata(cdata->ct, callspace);\
-			cdata->locals = locals = alloc_stack(cdata->ct, sizeof(localtype));
+				release_ref(cdata->params[0-idx]); cdata->num_params = numparams;\
+			lv_ ## name = alloc_stack(ct, sizeof(lt_ ## name));
+
 
-#define FuncNoLocals(name,numparams,callspace) \
-	returntype f_ ## name (calldata * cdata)\
-	{\
-		calldata *call;\
-		returntype ret;\
-		int idx;\
-		if(cdata->resume)\
-			call = cdata->locals;\
-		switch(cdata->resume)\
+#define FuncNoLocals(name,numparams) \
+	case FUNC_ ## name:\
+f_ ## name:\
+		switch(resume)\
 		{\
 		case 0:\
 			for(idx = numparams; idx < cdata->num_params; ++idx)\
-				release_ref(cdata->params[idx]);\
-			cdata->num_params = numparams;\
-			cdata->locals = call = alloc_cdata(cdata->ct, callspace);
+				release_ref(cdata->params[0-idx]); cdata->num_params = numparams;\
 
-#define EndFunc	\
-			free_stack(cdata->ct, call);\
-			return NORMAL_RETURN;\
-		}\
-	}
+#define EndFunc(name)	\
+			free_stack(ct, lv_ ## name);\
+			func = cdata->func;\
+			resume = cdata->resume;\
+			goto _dispatch;\
+		}
+	
+#define EndFuncNoLocals	\
+			func = cdata->func;\
+			resume = cdata->resume;\
+			goto _dispatch;\
+		}
 
-#define Method(name,type,numparams,callspace,localtype) \
-	returntype MethodName(name,type) (calldata * cdata)\
-	{\
-		localtype *locals;\
-		calldata *call;\
-		returntype ret;\
-		int idx;\
-		if(cdata->resume)\
-		{\
-			call = cdata->call;\
-			locals = cdata->locals;\
-		}\
-		switch(cdata->resume)\
+#define Method(name) \
+	case FUNC_ ## name:\
+f_ ## name:\
+		if (cdata->num_params < 1)\
+			goto _exception;\
+		switch(get_blueprint(cdata->params[0])->type_id)\
+		{
+			
+#define EndMethod \
+		default:\
+			goto _exception;\
+		}
+			
+			
+#define MethodDispatch(type_id,name,type_name) \
+		case type_id:\
+			goto m_ ## name ## _AT_ ## type_name;
+			
+#define MethodImpl(name,type_name,mytype_id,numparams) \
+	case FUNC_ ## name ## _AT_ ## type_name:\
+f_ ## name ## _AT_ ## type_name:\
+		switch(resume)\
 		{\
 		case 0:\
+			if (cdata->num_params < 1)\
+				goto _exception;\
+			if(get_blueprint(cdata->params[0])->type_id != mytype_id)\
+			{\
+				puts("uh oh, need conversion and that's not implemented yet!");\
+				exit(1);\
+			}\
+m_ ## name ## _AT_ ## type_name:\
 			for(idx = numparams; idx < cdata->num_params; ++idx)\
-				release_ref(cdata->params[idx]); cdata->num_params = numparams;\
-			cdata->num_params = numparams;\
-			cdata->call = call = alloc_cdata(cdata->ct, callspace);\
-			cdata->locals = locals = alloc_stack(cdata->ct, sizeof(localtype));
-
-#define MethodNoLocals(name,type,numparams,callspace) \
-	returntype MethodName(name,type) (calldata * cdata)\
-	{\
-		calldata *call;\
-		returntype ret;\
-		int idx;\
-		if(cdata->resume)\
-			call = cdata->locals;\
-		switch(cdata->resume)\
+				release_ref(cdata->params[0-idx]); cdata->num_params = numparams;\
+			lv_ ## name ## _AT_ ## type_name = alloc_stack(ct, sizeof(lt_ ## name ## _AT_ ## type_name));
+			
+				
+#define MethodImplNoLocals(name,type_name,mytype_id,numparams) \
+		case FUNC_ ## name ## _AT_ ## type_name:\
+f_ ## name ## _AT_ ## type_name:\
+		switch(resume)\
 		{\
 		case 0:\
+			if (cdata->num_params < 1)\
+				goto _exception;\
+			if(get_blueprint(cdata->params[0])->type_id != mytype_id)\
+			{\
+				puts("uh oh, need conversion and that's not implemented yet!");\
+				exit(1);\
+			}\
+m_ ## name ## _AT_ ## type_name:\
 			for(idx = numparams; idx < cdata->num_params; ++idx)\
-				release_ref(cdata->params[idx]);\
-			cdata->num_params = numparams;\
-			cdata->locals = call = alloc_cdata(cdata->ct, callspace);
-	
+				release_ref(cdata->params[0-idx]); cdata->num_params = numparams;
+			
 #define NumParams
 #define CallSpace
 
 #define Param(num,convtypeid) \
-	call->params[0] = cdata->params[num];\
-	call->resume = 0;\
-	ret = coerce_value(convtypeid, call);\
-	while(ret == TAIL_RETURN)\
-		ret = call->tail_func(call);\
-	if(ret == EXCEPTION_RETURN)\
+	if(get_blueprint(cdata->params[0-num])->type_id != convtypeid)\
 	{\
-		for(idx = 0; idx < cdata->num_params; ++idx)\
-			if(idx != num && cdata->params[idx])\
-				release_ref(cdata->params[idx]);\
-		cdata->params[0] = call->params[0];\
-		free_stack(cdata->ct, call);\
-		return ret;\
-	}\
-	cdata->params[num] = call->params[0];
+		puts("uh oh, need conversion and that's not implemented yet!");\
+		exit(1);\
+	}
 
 #define CopiedParam(num,convtypeid) Param(num,convtypeid) cdata->params[num] = copy_object(cdata->params[num]);
-#define Ret(num,val) cdata->params[num] = (object *)(val);
-#define Return return NORMAL_RETURN;
+#define Ret(num,val) cdata->params[0-num] = (object *)(val);
 #define Exception
-#define FuncDef(name) returntype f_ ## name (calldata * cdata);
-#define MethodDef(name,type) returntype MethodName(name,type) (calldata * cdata);
+#define FuncDef(name) lt_ ## name * lv_ ## name;
+#define MethodDef(name) lt_ ## name ## _AT_ ## type_name * lv_ ## name ## _AT_ ## type_name;
+
+
+#define PrepCall(callspace) cdata = alloc_cdata(ct, cdata, callspace);
 
-#define Call(func, numparams)\
-	call->num_params = numparams;\
-	call->resume = 0;\
-	ret = f_ ## func (call);\
-	while(ret == TAIL_RETURN)\
-		ret = call->tail_func(call);\
-	if(ret == EXCEPTION_RETURN)\
-	{\
-		for(idx = 0; idx < cdata->num_params; ++idx)\
-			if(cdata->params[idx])\
-				release_ref(cdata->params[idx]);\
-		cdata->params[0] = call->params[0];\
-		free_stack(cdata->ct, call);\
-		return ret;\
-	}
-	
-#define MCall(methodid, numparams)\
-	call->num_params = numparams;\
-	call->resume = 0;\
-	ret = call_method(methodid, call);\
-	while(ret == TAIL_RETURN)\
-		ret = call->tail_func(call);\
-	if(ret == EXCEPTION_RETURN)\
-	{\
-		for(idx = 0; idx < cdata->num_params; ++idx)\
-			if(cdata->params[idx])\
-				release_ref(cdata->params[idx]);\
-		cdata->params[0] = call->params[0];\
-		free_stack(cdata->ct, call);\
-		return ret;\
-	}
+#define SetParam(num,value) cdata->params[0-num] = value;
+
+#define Call(tocall, numparams, resumeto, myname)\
+				cdata->func = FUNC_ ## myname;\
+				cdata->resume = resumeto;\
+				cdata->num_params = numparams;\
+				resume = 0;\
+				goto f_ ## tocall;\
+			case resumeto:\
+				lv_ ## myname = (lt_ ## myname *)(cdata->lastframe+1);
 	
-#define GFieldCall(fieldid)\
-	call->num_params = 1;\
-	call->resume = 0;\
-	ret = get_field(fieldid, call);\
-	while(ret == TAIL_RETURN)\
-		ret = call->tail_func(call);\
-	if(ret == EXCEPTION_RETURN)\
-	{\
-		for(idx = 0; idx < cdata->num_params; ++idx)\
-			if(cdata->params[idx])\
-				release_ref(cdata->params[idx]);\
-		cdata->params[0] = call->params[0];\
-		free_stack(cdata->ct, call);\
-		return ret;\
-	}
-	
-#define SFieldCall(fieldid)\
-	call->num_params = 2;\
-	call->resume = 0;\
-	ret = set_field(fieldid, call);\
-	while(ret == TAIL_RETURN)\
-		ret = call->tail_func(call);\
-	if(ret == EXCEPTION_RETURN)\
-	{\
-		for(idx = 0; idx < cdata->num_params; ++idx)\
-			if(cdata->params[idx])\
-				release_ref(cdata->params[idx]);\
-		cdata->params[0] = call->params[0];\
-		free_stack(cdata->ct, call);\
-		return ret;\
-	}
+#define FreeCall\
+				temp_cdata = cdata->lastframe;\
+				free_stack(ct, cdata);\
+				cdata = temp_cdata;
 
-#define TMCall(methodid, numparams)\
-	free_stack(cdata->ct, call);\
-	cdata->num_params = numparams;\
-	cdata->resume = 0;\
-	ret = call_method(methodid, cdata);\
-	return ret;
+#define FreeCallMethod(myname,mytype)\
+				temp_cdata = cdata->lastframe;\
+				free_stack(ct, cdata);\
+				cdata = temp_cdata;\
+				lv_ ## myname ## _AT_ ## type_name = (lt_ ## myname ## _AT_ ## type_name *)(cdata+1);
 	
 #define TCall(func, numparams)\
 	free_stack(cdata->ct, call);\