sml/funcsig.h

Go to the documentation of this file.

/******************************************************************************
 *
 * \file sml/funcsig.h
 * \brief SML Function signatures
 *
 * \if NODOC
 * $Log: funcsig.h_v $
 * Revision 1.2  2007/05/08 15:45:51  dwilliss
 * SML namespace
 *
 * Revision 1.1  2007/05/04 21:33:08  dwilliss
 * Initial revision
 *
 * \endif
*/
/*****************************************************************************/

#ifndef INC_SML_FUNCSIG_H
#define INC_SML_FUNCSIG_H

#ifndef INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif


#define ARGT_v    0     // (void)   (return type only)
#define ARGT_b    1     // (bool)
#define ARGT_d    2     // (double)
#define ARGT_i    3     // (INT32)
#define ARGT_u    4     // (UINT32)
#define ARGT_pv   5     // (void*)
#define ARGT_U    6     // (MIUNICODE*)
#define ARGT_cU   7     // (const MIUNICODE*)
#define ARGT_c    8     // (char*)
#define ARGT_cc   9     // (const char*)
#define ARGT_pva  10    // (void*) that we need to free

#define DEFSIG0(ret) (ret)
#define DEFSIG1(ret, a) (a << 4) | ret
#define DEFSIG2(ret, a, b) (b << 8) | (a << 4) | ret
#define DEFSIG3(ret, a, b, c) (c << 12) | (b << 8) | (a << 4) | ret
#define DEFSIG4(ret, a, b, c, d) (d << 16) | (c << 12) | (b << 8) | (a << 4) | ret
// NOTE: DEFSIG5 isn't defined because the SML runtime only supports passing
// up to 4 parameters this way
//#define DEFSIG5(ret, a, b, c, d, e) (d <<20) | (d << 16) | (c << 12) | (b << 8) | (a << 4) | ret




#define DEFSIG_0(LHS, TYPE, RHS, N) \
   LHS##TYPE  = (RHS | (ARGT_##TYPE << ((N)*4))),

#define DEFSIG_1(LHS, TYPE, RHS, N) \
   LHS##TYPE  = (RHS | (ARGT_##TYPE << ((N)*4))),  \
   DEFSIG_0(LHS##TYPE##_, d,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_0(LHS##TYPE##_, b,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_0(LHS##TYPE##_, i,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_0(LHS##TYPE##_, u,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_0(LHS##TYPE##_, pv, (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_0(LHS##TYPE##_, U,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_0(LHS##TYPE##_, cU, (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_0(LHS##TYPE##_, c,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_0(LHS##TYPE##_, cc, (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \

#define DEFSIG_2(LHS, TYPE, RHS, N) \
   LHS##TYPE  = (RHS | (ARGT_##TYPE << ((N)*4))),  \
   DEFSIG_1(LHS##TYPE##_, d,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_1(LHS##TYPE##_, b,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_1(LHS##TYPE##_, i,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_1(LHS##TYPE##_, u,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_1(LHS##TYPE##_, pv, (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_1(LHS##TYPE##_, U,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_1(LHS##TYPE##_, cU, (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_1(LHS##TYPE##_, c,  (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \
   DEFSIG_1(LHS##TYPE##_, cc, (RHS | (ARGT_##TYPE << ((N) * 4))), N+1)  \

#define DEFSIG  DEFSIG_2(SIG_, v, 0, 0) \
                DEFSIG_2(SIG_, d, 0, 0) \
                DEFSIG_2(SIG_, b, 0, 0) \
                DEFSIG_2(SIG_, i, 0, 0) \
                DEFSIG_2(SIG_, u, 0, 0) \
                DEFSIG_2(SIG_, pv, 0, 0) \
                DEFSIG_2(SIG_, U, 0, 0) \
                DEFSIG_2(SIG_, cU, 0, 0) \
                DEFSIG_2(SIG_, c, 0, 0) \
                DEFSIG_2(SIG_, cc, 0, 0) \
                DEFSIG_2(SIG_, pva, 0, 0)


enum SMLFUNCSIG {
   SIG_OldStyle = 0,
   DEFSIG

   SIG_v_i_i_b = DEFSIG3(ARGT_v, ARGT_i, ARGT_i, ARGT_b),
   SIG_v_i_i_i = DEFSIG3(ARGT_v, ARGT_i, ARGT_i, ARGT_i),
   SIG_v_i_i_i_b = DEFSIG4(ARGT_v, ARGT_i, ARGT_i, ARGT_i, ARGT_b),
   SIG_v_d_d_b = DEFSIG3(ARGT_v, ARGT_d, ARGT_d, ARGT_b),
   SIG_v_d_d_d = DEFSIG3(ARGT_v, ARGT_d, ARGT_d, ARGT_d),
   SIG_v_d_d_d_d = DEFSIG4(ARGT_v, ARGT_d, ARGT_d, ARGT_d, ARGT_d),
   SIG_v_pv_cU_i = DEFSIG3(ARGT_v, ARGT_pv, ARGT_cU, ARGT_i),
   SIG_v_pv_pv_pv = DEFSIG3(ARGT_v, ARGT_pv, ARGT_pv, ARGT_pv),
   SIG_v_pv_pv_d = DEFSIG3(ARGT_v, ARGT_pv, ARGT_pv, ARGT_d),
   SIG_i_pv_b_pv = DEFSIG3(ARGT_i, ARGT_pv, ARGT_b, ARGT_pv),
   SIG_i_pv_pv_pv_d = DEFSIG4(ARGT_i, ARGT_pv, ARGT_pv, ARGT_pv, ARGT_d),
   SIG_i_u_pv_pv = DEFSIG3(ARGT_i, ARGT_u, ARGT_pv, ARGT_pv),
   SIG_i_i_d_d = DEFSIG3(ARGT_i, ARGT_i, ARGT_d, ARGT_d),
   SIG_i_i_i_d = DEFSIG3(ARGT_i, ARGT_i, ARGT_i, ARGT_d),
   SIG_i_pv_d_d = DEFSIG3(ARGT_i, ARGT_pv, ARGT_d, ARGT_d),
   SIG_i_d_d_d = DEFSIG3(ARGT_i, ARGT_d, ARGT_d, ARGT_d),
   SIG_i_d_pv_d_d = DEFSIG4(ARGT_i, ARGT_d, ARGT_pv, ARGT_d, ARGT_d),
   SIG_i_pv_pv_b = DEFSIG3(ARGT_i, ARGT_pv, ARGT_pv, ARGT_b),

   SIG_LAST
   };

typedef void (*FUNCPTR_v)();
typedef double (*FUNCPTR_d)();
typedef bool (*FUNCPTR_b)();
typedef INT32 (*FUNCPTR_i)();
typedef UINT32 (*FUNCPTR_u)();
typedef void* (*FUNCPTR_vp)();
typedef MIUNICODE* (*FUNCPTR_U)();
typedef const MIUNICODE* (*FUNCPTR_cU)();
typedef char* (*FUNCPTR_c)();
typedef const char* (*FUNCPTR_cc)();

typedef void (*FUNCPTR_v_b)(bool);

namespace SML {

typedef enum ::SMLFUNCSIG FUNCSIG;

inline int FUNCSIG_GetNumParms (
   SMLFUNCSIG sig
   ) {
   UINT32 x = sig;
   int num = 0;
   x >>= 4;
   while (x) {
      x >>= 4;
      ++num;
      }
   return num;
   }

inline SMLFUNCSIG FUNCSIG_GetRetType (
   SMLFUNCSIG sig
   ) {
   UINT32 x = sig;
   return ((SMLFUNCSIG)(x & 0x0F));
   }

inline SMLFUNCSIG FUNCSIG_GetParmType (
   SMLFUNCSIG sig,
   int n    
   ) {
   UINT32 x = sig;
   x >>= ((n + 1) * 4);
   return ((SMLFUNCSIG)(x & 0x0F));
   }

} // end of SML namespace


#endif      //  INC_SML_FUNCSIG_H

---