From 9815096db22c73cacdbb65512d1b61d633db7fa8 Mon Sep 17 00:00:00 2001
From: Thomas Grill <xovo@users.sourceforge.net>
Date: Mon, 2 Dec 2002 19:21:08 +0000
Subject:  "version 0.1.1"

svn path=/trunk/; revision=267
---
 externals/grill/vasp/source/opdefs.h | 364 +++++++++++++++++++++++++++++++++++
 1 file changed, 364 insertions(+)
 create mode 100644 externals/grill/vasp/source/opdefs.h

(limited to 'externals/grill/vasp/source/opdefs.h')

diff --git a/externals/grill/vasp/source/opdefs.h b/externals/grill/vasp/source/opdefs.h
new file mode 100644
index 00000000..bf9101f7
--- /dev/null
+++ b/externals/grill/vasp/source/opdefs.h
@@ -0,0 +1,364 @@
+/* 
+
+VASP modular - vector assembling signal processor / objects for Max/MSP and PD
+
+Copyright (c) 2002 Thomas Grill (xovo@gmx.net)
+For information on usage and redistribution, and for a DISCLAIMER OF ALL
+WARRANTIES, see the file, "license.txt," in this distribution.  
+
+*/
+
+#ifndef __VASP_OPDEFS_H
+#define __VASP_OPDEFS_H
+
+#include "oploop.h"
+
+#ifdef VASP_CHN1  
+#define _D_ALWAYS1 1
+#else
+#define _D_ALWAYS1 0
+#endif
+
+/*! \brief skeleton for unary real operations
+*/
+#define _D__run(fun,p)											\
+{																\
+	register const S *sr = p.rsdt;								\
+	register S *dr = p.rddt;									\
+	register I i;												\
+	if(sr == dr)												\
+		if(_D_ALWAYS1 || p.rds == 1)							\
+			_D_LOOP(i,p.frames)									\
+			{ fun(*dr,*dr); dr++; }								\
+			_E_LOOP												\
+		else													\
+			_D_LOOP(i,p.frames)									\
+			{ fun(*dr,*dr); dr += p.rds; }						\
+			_E_LOOP												\
+	else														\
+		if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1))			\
+			_D_LOOP(i,p.frames)									\
+			{ fun(*dr,*sr); sr++,dr++; }						\
+			_E_LOOP												\
+		else													\
+			_D_LOOP(i,p.frames)									\
+			{ fun(*dr,*sr); sr += p.rss,dr += p.rds; }			\
+			_E_LOOP												\
+	return true;												\
+}
+
+#define d__run(fun,p) { return _d__run(fun,p); }
+
+/*! \brief skeleton for unary complex operations
+*/
+#define _D__cun(fun,p)											\
+{																\
+	register const S *sr = p.rsdt,*si = p.isdt;					\
+	register S *dr = p.rddt,*di = p.iddt;						\
+	register I i;												\
+	if(sr == dr && si == di)									\
+		if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1))			\
+			_D_LOOP(i,p.frames)									\
+			{ fun(*dr,*di,*dr,*di); dr++,di++; }				\
+			_E_LOOP												\
+		else													\
+			_D_LOOP(i,p.frames)									\
+			{ fun(*dr,*di,*dr,*di); dr += p.rds,di += p.ids; }	\
+			_E_LOOP												\
+	else														\
+		if(_D_ALWAYS1 || (p.rss == 1 && p.iss == 1 && p.rds == 1 && p.ids == 1)) \
+			_D_LOOP(i,p.frames)									\
+			{ fun(*dr,*di,*sr,*si); sr++,si++,dr++,di++; }		\
+			_E_LOOP												\
+		else													\
+			_D_LOOP(i,p.frames)									\
+			{ fun(*dr,*di,*sr,*si);	sr += p.rss,si += p.iss,dr += p.rds,di += p.ids; } \
+			_E_LOOP												\
+	return true;												\
+}
+
+#define d__cun(fun,p) { return _d__cun(fun,p); }
+
+
+/*! \brief skeleton for binary real operations
+*/
+#define _D__rbin(fun,p)											\
+{																\
+	register const S *sr = p.rsdt;								\
+	register S *dr = p.rddt;									\
+	register I i;												\
+	if(p.HasArg() && p.arg[0].Is()) {											\
+		switch(p.arg[0].argtp) {									\
+		case OpParam::Arg::arg_v: {								\
+			register const S *ar = p.arg[0].v.rdt;					\
+			if(p.rsdt == p.rddt)									\
+				if(_D_ALWAYS1 || (p.rds == 1 && p.arg[0].v.rs == 1))				\
+					_D_LOOP(i,p.frames)									\
+					{ fun(*dr,*dr,*ar); dr++,ar++; }				\
+					_E_LOOP												\
+				else												\
+					_D_LOOP(i,p.frames)									\
+					{ fun(*dr,*dr,*ar);	dr += p.rds,ar += p.arg[0].v.rs; } \
+					_E_LOOP												\
+			else													\
+				if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1 && p.arg[0].v.rs == 1))	\
+					_D_LOOP(i,p.frames)									\
+					{ fun(*dr,*sr,*ar); sr++,dr++,ar++; }			\
+					_E_LOOP												\
+				else												\
+					_D_LOOP(i,p.frames)									\
+					{ fun(*dr,*sr,*ar);	sr += p.rss,dr += p.rds,ar += p.arg[0].v.rs; } \
+					_E_LOOP												\
+			break;												\
+		}														\
+		case OpParam::Arg::arg_env: {							\
+			Env::Iter it(*p.arg[0].e.env); it.Init(0);			\
+			if(p.rsdt == p.rddt)									\
+				if(_D_ALWAYS1 || p.rds == 1)										\
+					_D_LOOP(i,p.frames)									\
+					{ fun(*dr,*dr,it.ValFwd(i)); dr++; }			\
+					_E_LOOP												\
+				else												\
+					_D_LOOP(i,p.frames)									\
+					{ fun(*dr,*dr,it.ValFwd(i)); dr += p.rds; }		\
+					_E_LOOP												\
+			else													\
+				if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1))						\
+					_D_LOOP(i,p.frames)									\
+					{ fun(*dr,*sr,it.ValFwd(i)); sr++,dr++; }		\
+					_E_LOOP												\
+				else												\
+					_D_LOOP(i,p.frames)								 	\
+					{ fun(*dr,*sr,it.ValFwd(i)); sr += p.rss,dr += p.rds; }	\
+					_E_LOOP												\
+			break;												\
+		}														\
+		case OpParam::Arg::arg_x: {							\
+			const R v =  p.arg[0].x.r;							\
+			if(p.rsdt == p.rddt)									\
+				if(_D_ALWAYS1 || p.rds == 1)										\
+					_D_LOOP(i,p.frames)									\
+					{ fun(*dr,*dr,v); dr++; }						\
+					_E_LOOP												\
+				else												\
+					_D_LOOP(i,p.frames)								 	\
+					{ fun(*dr,*dr,v); dr += p.rds; }				\
+					_E_LOOP												\
+			else													\
+				if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1))						\
+					_D_LOOP(i,p.frames)									\
+					{ fun(*dr,*sr,v); sr++,dr++; }					\
+					_E_LOOP												\
+				else												\
+					_D_LOOP(i,p.frames)								 	\
+					{ fun(*dr,*sr,v); sr += p.rss,dr += p.rds; }	\
+					_E_LOOP												\
+			break;												\
+		}														\
+		}														\
+	}															\
+	else {														\
+		register const S v = p.rbin.arg;						\
+		if(p.rsdt == p.rddt)									\
+			if(_D_ALWAYS1 || p.rds == 1)										\
+				_D_LOOP(i,p.frames)									\
+				{ fun(*dr,*dr,v); dr++; }						\
+				_E_LOOP												\
+			else												\
+				_D_LOOP(i,p.frames)									\
+				{ fun(*dr,*dr,v); dr += p.rds; }				\
+				_E_LOOP												\
+		else													\
+			if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1))						\
+				_D_LOOP(i,p.frames)									\
+				{ fun(*dr,*sr,v); sr++,dr++; }					\
+				_E_LOOP												\
+			else												\
+				_D_LOOP(i,p.frames)									\
+				{ fun(*dr,*sr,v); sr += p.rss,dr += p.rds; }	\
+				_E_LOOP												\
+	}															\
+	return true;												\
+}
+
+#define d__rbin(fun,p) { return _d__rbin(fun,p); }
+
+
+/*! \brief skeleton for binary complex operations
+*/
+#define _D__cbin(fun,p)											\
+{																\
+	register const S *sr = p.rsdt,*si = p.isdt;					\
+	register S *dr = p.rddt,*di = p.iddt;						\
+	register I i;												\
+	if(p.HasArg() && p.arg[0].Is()) {											\
+		switch(p.arg[0].argtp) {									\
+		case OpParam::Arg::arg_v: {									\
+			register const S *ar = p.arg[0].v.rdt,*ai = p.arg[0].v.idt;				\
+			if(ai)													\
+				if(sr == dr && si == di)							\
+					if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1 && p.arg[0].v.rs == 1 && p.arg[0].v.is == 1)) \
+						_D_LOOP(i,p.frames)				 \
+						{ fun(*dr,*di,*dr,*di,*ar,*ai);	dr++,di++,ar++,ai++; }		\
+						_E_LOOP												\
+					else											\
+						_D_LOOP(i,p.frames)				 \
+						{ fun(*dr,*di,*dr,*di,*ar,*ai);	dr += p.rds,di += p.ids,ar += p.arg[0].v.rs,ai += p.arg[0].v.is; }		\
+						_E_LOOP												\
+				else												\
+					_D_LOOP(i,p.frames)				 \
+					{ fun(*dr,*di,*sr,*si,*ar,*ai);	sr += p.rss,si += p.iss,dr += p.rds,di += p.ids,ar += p.arg[0].v.rs,ai += p.arg[0].v.is; }			\
+					_E_LOOP												\
+			else													\
+				if(sr == dr && si == di)							\
+					_D_LOOP(i,p.frames)				 \
+					{ fun(*dr,*di,*dr,*di,*ar,0); dr += p.rds,di += p.ids,ar += p.arg[0].v.rs; }	\
+					_E_LOOP												\
+				else												\
+					_D_LOOP(i,p.frames)				 \
+					{ fun(*dr,*di,*sr,*si,*ar,0); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids,ar += p.arg[0].v.rs; } \
+					_E_LOOP												\
+			break;												\
+		}														\
+		case OpParam::Arg::arg_env: {									\
+			Env::Iter it(*p.arg[0].e.env); it.Init(0);				\
+			if(sr == dr && si == di)							\
+				if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1)) \
+					_D_LOOP(i,p.frames)				 \
+					{ fun(*dr,*di,*dr,*di,it.ValFwd(i),0); dr++,di++; }			\
+					_E_LOOP												\
+				else											\
+					_D_LOOP(i,p.frames)				 \
+					{ fun(*dr,*di,*dr,*di,it.ValFwd(i),0); dr += p.rds,di += p.ids; }			\
+					_E_LOOP												\
+			else												\
+				_D_LOOP(i,p.frames)				 \
+					{ fun(*dr,*di,*sr,*si,it.ValFwd(i),0); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids; }	\
+				_E_LOOP												\
+			break;												\
+		}														\
+		case OpParam::Arg::arg_x: {									\
+			register const R ar = p.arg[0].x.r,ai = p.arg[0].x.i;				\
+			if(sr == dr && si == di)							\
+				if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1)) \
+					_D_LOOP(i,p.frames)				 \
+					{ fun(*dr,*di,*dr,*di,ar,ai); dr++,di++; }			\
+					_E_LOOP												\
+				else											\
+					_D_LOOP(i,p.frames)				 \
+					{ fun(*dr,*di,*dr,*di,ar,ai); dr += p.rds,di += p.ids; }			\
+					_E_LOOP												\
+			else												\
+				_D_LOOP(i,p.frames)				 \
+				{ fun(*dr,*di,*sr,*si,ar,ai); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids; }	\
+				_E_LOOP												\
+			break;												\
+		}														\
+		}														\
+	}															\
+	else {														\
+		register const S rv = p.cbin.rarg,iv = p.cbin.iarg;		\
+		if(sr == dr && si == di)								\
+			if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1))						\
+				_D_LOOP(i,p.frames)						\
+				{ fun(*dr,*di,*dr,*di,rv,iv); dr++,di++; }					\
+				_E_LOOP												\
+			else												\
+				_D_LOOP(i,p.frames)				 \
+				{ fun(*dr,*di,*dr,*di,rv,iv); dr += p.rds,di += p.ids; }					\
+				_E_LOOP												\
+		else													\
+			if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1 && p.rss == 1 && p.iss == 1)) \
+				_D_LOOP(i,p.frames)				 \
+				{ fun(*dr,*di,*sr,*si,rv,iv); sr++,si++,dr++,di++; }					\
+				_E_LOOP												\
+			else												\
+				_D_LOOP(i,p.frames)				 \
+				{ fun(*dr,*di,*sr,*si,rv,iv); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids; }					\
+				_E_LOOP												\
+	}															\
+	return true;												\
+}
+
+#define d__cbin(fun,p) { return _d__cbin(fun,p); }
+
+
+/*! \brief skeleton for real operations with parameter block
+*/
+#define _D__rop(fun,p)											\
+{																\
+	register const S *sr = p.rsdt;								\
+	register S *dr = p.rddt;									\
+	register I i;												\
+	if(sr == dr)												\
+		if(_D_ALWAYS1 || p.rds == 1)											\
+			_D_LOOP(i,p.frames)										\
+			{ fun(*dr,*dr,p); dr++; }							\
+			_E_LOOP												\
+		else													\
+			_D_LOOP(i,p.frames)										\
+			{ fun(*dr,*dr,p); dr += p.rds; }					\
+			_E_LOOP												\
+	else														\
+		if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1))							\
+			_D_LOOP(i,p.frames)										\
+			{ fun(*dr,*sr,p); sr++,dr++; }						\
+			_E_LOOP												\
+		else													\
+			_D_LOOP(i,p.frames)										\
+			{ fun(*dr,*sr,p); sr += p.rss,dr += p.rds; }		\
+			_E_LOOP												\
+	return true;												\
+}
+
+#define d__rop(fun,p) { return _d__rop(fun,p); }
+
+
+/*! \brief skeleton for complex operations with parameter block
+*/
+#define _D__cop(fun,p)											\
+{																\
+	register const S *sr = p.rsdt,*si = p.isdt;					\
+	register S *dr = p.rddt,*di = p.iddt;						\
+	register I i;												\
+	if(sr == dr && si == di)									\
+		if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1))							\
+			_D_LOOP(i,p.frames)										\
+			{ fun(*dr,*di,*dr,*di,p); dr++,di++; }				\
+			_E_LOOP												\
+		else													\
+			_D_LOOP(i,p.frames)										\
+			{ fun(*dr,*di,*dr,*di,p); dr += p.rds,di += p.ids; } \
+			_E_LOOP												\
+	else														\
+		if(_D_ALWAYS1 || (p.rss == 1 && p.iss == 1 && p.rds == 1 && p.ids == 1)) \
+			_D_LOOP(i,p.frames)				 \
+			{ fun(*dr,*di,*sr,*si,p); sr++,si++,dr++,di++; }	\
+			_E_LOOP												\
+		else													\
+			_D_LOOP(i,p.frames)				 \
+			{ fun(*dr,*di,*sr,*si,p); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids; }	\
+			_E_LOOP												\
+	return true;												\
+}
+
+#define d__cop(fun,p) { return _d__cop(fun,p); }
+
+
+#ifdef VASP_COMPACT
+#define D__run(fun,p) d__run(fun,p)
+#define D__cun(fun,p) d__cun(fun,p)
+#define D__rbin(fun,p) d__rbin(fun,p)
+#define D__cbin(fun,p) d__cbin(fun,p)
+#define D__rop(fun,p) d__rop(fun,p)
+#define D__cop(fun,p) d__cop(fun,p)
+#else
+#define D__run(fun,p) _D__run(fun,p)
+#define D__cun(fun,p) _D__cun(fun,p)
+#define D__rbin(fun,p) _D__rbin(fun,p)
+#define D__cbin(fun,p) _D__cbin(fun,p)
+#define D__rop(fun,p) _D__rop(fun,p)
+#define D__cop(fun,p) _D__cop(fun,p)
+#endif
+
+#endif
-- 
cgit v1.2.1