mk_misc_check_lng.h

Go to the documentation of this file.

 
/* LABEL-NO */
 
/* variables defined - example from PYTHON
 
#define OT_LNG_NULL_IS(obj)               (obj == Py_None)
 
#define OT_LNG_OBJ_CLASS_IS(obj,cls)      PyObject_TypeCheck(obj,cls)
#define OT_OBJ_TO_CLASS(str)              NS(str)
 
#define OT_LNG_OBJ_ENUM_IS(obj,enm)       PyObject_TypeCheck(obj,enm)
#define OT_LNG_ENUM_NAME(enm)             OT_LNG_NAME_FROM_CLASS(enm)
#define OT_ENUM_TO_I32(io,o,e)   io=o
 
#define OT_LNG_ARRAY_IS(obj)              PyObject_TypeCheck(obj,&PyList_Type)
 
#define OT_LNG_STRN_PRE(str,obj)           PyObject *__##str=NULL; \
                                          MkErrorCheck(PyObj_AsUTF8(obj,&__##str)); \
                                          MK_STRN str=PyBytes_AsString(__##str)
 
#define OT_LNG_STRN_POST(str,obj)          Py_CLEAR(__##str)
 
#define OT_LNG_LONG_IS(obj)               (CHECK_LONG(obj) || CHECK_STRING(obj))   // from "high"
#define OT_LNG_I32_IS(obj)                (CHECK_LONG(obj) || CHECK_STRING(obj))    // from "high"
 
#include "tmpl/misc_check_lng.h"
 
*/
 
#if defined HEADER
 
// OLD: OT_CHECK_OBJ
#define OT_CHECK_LNG_T(val)                            \
  if (__skip >= objc) {                                  \
    MkErrorC_CheckD(WrongNumArgs(hdl,__skip, objc, -999, +999, #val));    \
  } else {                                             \
    val = (typeof(val)) OT_LNG_OBJV(__skip++);           \
  }
 
#define OT_CHECK_EXP(val)  OT_CHECK_LNG_T(val)
#define OT_CHECK_MXC(val)  OT_CHECK_LNG_T(val)
 
// OLD: OtCheckObject
MK_EXTERN enum MkErrorE MK_DECL MK(Check_MkObjectC)   (OT_Check_ARGS, MK_MNG*, bool);
#define OT_CHECK_MK_OBJECT_C(val,nullB) \
  MkErrorC_CheckD(MK(Check_MkObjectC) (OT_Check_CALL(#val), (MK_PTR*)&val, nullB));
 
#define OT_CHECK_OBJ(val,nullB)  OT_CHECK_MK_OBJECT_C(val,nullB)
#define OT_CHECK_OBJN(val,nullB) OT_CHECK_MK_OBJECT_C(val,nullB)
#define OT_CHECK_MNG(val)        OT_CHECK_MK_OBJECT_C(val,0)
#define OT_CHECK_ERC(val,nullB)  OT_CHECK_MK_OBJECT_C(val,nullB)
 
MK_EXTERN enum MkErrorE MK_DECL MK(CheckClass)    (OT_CLS_T, MK_TYP, OT_Check_ARGS, MK_MNG*, bool);
#define OT_CHECK_CLASS(val,classType,type,nullB) \
  MkErrorC_CheckD(MK(CheckClass) (classType, type, OT_Check_CALL(#val), (MK_PTR*)&val, nullB));
 
#define  OT_CHECK_BUF(val,nullB)  OT_CHECK_CLASS(val,  OT_OBJ_TO_CLASS(MkBufferC_lngO),        MkBufferC_TT,        nullB)
#define  OT_CHECK_BUS(val,nullB)  OT_CHECK_CLASS(val,  OT_OBJ_TO_CLASS(MkBufferStreamC_lngO),  MkBufferStreamC_TT,  nullB)
#define  OT_CHECK_ERR(val,nullB)  OT_CHECK_CLASS(val,  OT_OBJ_TO_CLASS(MkErrorC_lngO),         MkErrorC_TT,         nullB)
#define  OT_CHECK_LFL(val,nullB)  OT_CHECK_CLASS(val,  OT_OBJ_TO_CLASS(MkLogFileC_lngO),       MkLogFileC_TT,       nullB)
#define  OT_CHECK_RT(val,nullB)   OT_CHECK_CLASS(val,  OT_OBJ_TO_CLASS(MkRuntimeC_lngO),       MkRuntimeC_TT,       nullB)
 
#define  OT_CHECK_BUFN(val,nullB)  OT_CHECK_CLASS(val,  OT_OBJ_TO_CLASS(MkBufferC_lngO),        MkBufferC_TT,       nullB)
#define  OT_CHECK_BUSN(val,nullB)  OT_CHECK_CLASS(val,  OT_OBJ_TO_CLASS(MkBufferStreamC_lngO),  MkBufferStreamC_TT, nullB)
#define  OT_CHECK_ERRN(val,nullB)  OT_CHECK_CLASS(val,  OT_OBJ_TO_CLASS(MkErrorC_lngO),         MkErrorC_TT,        nullB)
#define  OT_CHECK_LFLN(val,nullB)  OT_CHECK_CLASS(val,  OT_OBJ_TO_CLASS(MkLogFileC_lngO),       MkLogFileC_TT,      nullB)
#define  OT_CHECK_RTN(val,nullB)   OT_CHECK_CLASS(val,  OT_OBJ_TO_CLASS(MkRuntimeC_lngO),       MkRuntimeC_TT,      nullB)
 
MK_EXTERN enum MkErrorE MK_DECL MK(CheckBAC)      (OT_Check_ARGS, MK_BFL*, bool);
#define OT_CHECK_BAC(val) \
  MkErrorC_CheckD(MK(CheckBAC(OT_Check_CALL(#val),&val,true)));
 
MK_EXTERN enum MkErrorE MK_DECL MK(CheckBLC)      (OT_Check_ARGS, MK_BFL*, bool);
#define OT_CHECK_BFL(val,nullB) \
  MkErrorC_CheckD(MK(CheckBLC) (OT_Check_CALL(#val), &val, nullB));
#define OT_CHECK_BFLN(val,nullB) \
  MkErrorC_CheckD(MK(CheckBLC) (OT_Check_CALL(#val), &val, nullB));
 
#if !defined(NO_OtCheckEnum)
  MK_EXTERN enum MkErrorE MK_DECL MK(CheckEnum) (OT_ENUM_T classType, OT_Check_ARGS, int*);
  #define OT_CHECK_ENUM(ename,val) {                                    \
      MK_I32 i;                                                         \
      MkErrorC_CheckD(MK(CheckEnum)(OT_OBJ_TO_ENUM(ename),OT_Check_CALL(#val),&i)); \
      MkErrorC_CheckD(ename##_FromInt(i,&val));                         \
    };
#endif
 
#if !defined(NO_OtCheckEnumFlag)
  MK_EXTERN enum MkErrorE MK_DECL MK(CheckEnumFlag)     (OT_ENUM_T classType, OT_Check_ARGS, int*);
  #define OT_CHECK_ENUM_FLAG(ename,val) {                                    \
      MK_I32 i;                                                         \
      MkErrorC_CheckD(MK(CheckEnumFlag)(OT_OBJ_TO_ENUM(ename),OT_Check_CALL(#val),&i)); \
      val = (enum ename) i;                                             \
    };
#endif
 
#if !defined(NO_OtCheckTimeT)
  MK_EXTERN enum MkErrorE MK_DECL MK(CheckTimeT)    (OT_Check_ARGS, MK_TIME_T*);
  #define OT_CHECK_TIME_T(val) \
    MkErrorC_CheckD(MK(CheckTimeT)(OT_Check_CALL(#val),&val));
#endif
 
#if !defined(NO_OtCheckCallable)
  MK_EXTERN enum MkErrorE MK_DECL         MK(CheckCallable) (OT_Check_ARGS, MK_CBP*);
  #define OT_SETUP_CALLABLE(val)          MK_CBP val = 0;
  #define OT_SETUP_CALLABLE_ONCE(val)     struct MkCallS val ## _ref = {0}; MK_CBP val = &val ## _ref;
  #define OT_CLEANUP_CALLABLE(val)
  // why? #define OT_CLEANUP_CALLABLE_ONCE(val)   do {MK_CBP val##_tmp=&val##_ref;MkCallFreeOnce(val##_tmp);} while (0);
  #define OT_CLEANUP_CALLABLE_ONCE(val)   MkCallFreeOnce(val);
  #define OT_CHECK_CALLABLE(val)          MkErrorC_CheckD(MK(CheckCallable)(OT_Check_CALL(#val), &val));
  #define MkCallFree(cb)                  if (cb) MK(CallFree)(&(cb))
  #define MkCallFreeOnce(cb)              if (cb) MK(CallFreeOnce)(&(cb))
#endif
 
#define NullNotAllowd(_cls) do { \
    MkErrorVD("NullNotAllowedError", "'%s' hdl is NULL", OT_LNG_NAME_FROM_CLASS(_cls) ); \
    goto error; \
  } while (0)
 
#define WrongTypeOfArgError(exp,got) do { \
    MkErrorVD("WrongTypeOfArgError", "for argument '%s'...expect type '%s'...but got '%s'", arg, exp, got ); \
    goto error; \
  } while (0)
 
#define WrongCallableError(got) do { \
    MkErrorVD("WrongTypeOfArgError", "for argument '%s'...expect type 'Callable'...but got '%s'", arg, got ); \
    goto error; \
  } while (0)
 
#define SignaturError(str) do { \
    MkErrorVD("SignaturError", "%s", str); \
    goto error; \
  } while (0)
 
#define InternalError(str) do { \
    MkErrorVD("InternalError", "%s", str); \
    goto error; \
  } while (0)
 
typedef enum MkTestClassE {
  MkTestClassE_OK                 = 0 ,
  MkTestClassE_NULL                   ,
  MkTestClassE_INVALID_SIGNATURE      ,
  MkTestClassE_NONE_OBJECT            ,
  MkTestClassE_WRONG_CLASS            ,
  MkTestClassE_INTERNAL               ,
} MkTestClassE;
 
#if !defined(NO_TestObject)
bool MK(TestObject) ( OT_Prefix_ARGS OT_OBJ_T lngO, OT_CLS_T typeO, MK_OBJ* objP, MkTestClassE* flagP );
#define OT_LNG_OBJ_CLASS_IS_4(val,cls,objP,flagP) MK(TestObject)( OT_Prefix_CALL val,cls,objP,flagP)
#define OT_LNG_OBJECT_IS_3(objV,obj,flag)         MK(TestObject)( OT_Prefix_CALL objV,MkObjectC_lngO,obj,flag)
#endif
 
 
#else // !HEADER
 
enum MkErrorE MK(Check_MkObjectC) (
  OT_Check_ARGS,
  MK_PTR          *retP,
  bool            nullB
) {
  if ((*skipP) >= objc) {
    WrongNumArgs(hdl,(*skipP), objc, -999, +999, arg);
    goto error;
  }
  OT_OBJ_T objV = OT_LNG_OBJV((*skipP)++);
  MK_OBJ obj = NULL;
  MkTestClassE flag;
 
  if (OT_LNG_OBJECT_IS_3(objV,&obj,&flag)) {
    switch (flag) {
      case MkTestClassE_OK                : *retP = (MK_PTR) obj;       break;
      case MkTestClassE_NULL              : 
        if (nullB) {
          *retP = NULL;
        } else {
          NullNotAllowd(MkObjectC_lngO); 
        }
        break;
      case MkTestClassE_INVALID_SIGNATURE : 
        SignaturError("MkObjectC") ;
      case MkTestClassE_WRONG_CLASS       :
        WrongTypeOfArgError(OT_LNG_NAME_FROM_CLASS(MkObjectC_lngO), OT_LNG_OBJ_CLASSNAME(objV));
      case MkTestClassE_NONE_OBJECT       :
      case MkTestClassE_INTERNAL          : 
        InternalError("OT_LNG_OBJECT_IS_3") ;
    }
  } else {
    WrongTypeOfArgError(OT_LNG_NAME_FROM_CLASS(MkObjectC_lngO), OT_OBJ_TYPE_STRING(objV));
  }
  return MK_OK;
error:
  return OT_ERROR_STACK;
}
 
enum MkErrorE MK(CheckClass) (
  OT_CLS_T        classType,
  MK_TYP          type,
  OT_Check_ARGS,
  MK_PTR          *retP,
  bool            nullB
) {
  if ((*skipP) >= objc) {
    WrongNumArgs(hdl, (*skipP), objc, -999, +999, arg);
    goto error;
  }
  OT_OBJ_T objV = OT_LNG_OBJV((*skipP)++);
  MK_OBJ obj = NULL;
  MkTestClassE flag;
 
  if (OT_LNG_OBJ_CLASS_IS_4(objV,classType,&obj,&flag)) {
    switch (flag) {
      case MkTestClassE_OK                : *retP = (MK_PTR) obj;       break;
      case MkTestClassE_NULL              : 
        if (nullB) {
          *retP = NULL;
        } else {
          NullNotAllowd(classType); 
        }
        break;
      case MkTestClassE_INVALID_SIGNATURE : 
        SignaturError(OT_LNG_NAME_FROM_CLASS(classType)) ;
      case MkTestClassE_WRONG_CLASS       :
        WrongTypeOfArgError(OT_LNG_NAME_FROM_CLASS(classType), OT_LNG_OBJ_CLASSNAME(objV));
      case MkTestClassE_NONE_OBJECT       :
      case MkTestClassE_INTERNAL          : 
        InternalError("OT_LNG_OBJECT_IS_3") ;
    }
  } else {
    WrongTypeOfArgError(OT_LNG_NAME_FROM_CLASS(classType), OT_OBJ_TYPE_STRING(objV));
  }
  return MK_OK;
error:
  return OT_ERROR_STACK;
}
 
enum MkErrorE MK(CheckBAC) (
  OT_Check_ARGS,
  MK_BFL      *retP,
  bool        nullB
) {
  OT_LNG_SKIP_TYPE skip = *skipP;
 
//printV("skip=%d, objc=%d\n", skip, objc)
  MK_BFL orig   = *retP;
  MK_BFL retVal = *retP;
  *retP = NULL;
  MkTestClassE flag;
  MK_OBJ obj;
 
  if (skip > objc) {
    WrongNumArgs(hdl, skip, objc, -999, +999, arg);
    goto error;
  }
 
  if ((objc-skip) == 0) {
    if (retVal == NULL) retVal = MkBufferListCreate(1);
  } else if ((objc-skip) == 1) {
    OT_OBJ_T argsO = OT_LNG_OBJV((*skipP)++);
    if (OT_LNG_OBJ_CLASS_IS_4(argsO, OT_OBJ_TO_CLASS(MkBufferListC_lngO), &obj, &flag)) {
      switch (flag) {
        case MkTestClassE_OK                : 
          retVal = MkBfl(obj);
          if (retVal == NULL) SignaturError("MkBufferListC") ;
          break;
        case MkTestClassE_WRONG_CLASS       :
          if (OT_LNG_ARRAY_IS(argsO)) {
            MkErrorCheck(MK(LngListToMkBufferListS) (OT_Prefix_CALL argsO, &retVal));
          } else {
            WrongTypeOfArgError("[array] or args... or MkBufferListC", OT_LNG_OBJ_CLASSNAME(argsO));
          }
          break;
        case MkTestClassE_NULL              : 
          if (nullB) {
            retVal = NULL;
          } else {
            NullNotAllowd(MkBufferListC_lngO); 
          }
          break;
        case MkTestClassE_INVALID_SIGNATURE : 
          SignaturError("MkBufferListC") ;
        case MkTestClassE_NONE_OBJECT       :
        case MkTestClassE_INTERNAL          : 
          InternalError("OT_LNG_OBJECT_IS_3") ;
      }
    } else if (OT_LNG_ARRAY_IS(argsO)) {
      MkErrorCheck(MK(LngListToMkBufferListS) (OT_Prefix_CALL argsO, &retVal));
    } else {
      if (retVal == NULL) retVal = MkBufferListCreate(1);
      OT_LNG_STRN_PRE(cst,argsO);
      MkBufferListAppendSTR(retVal,cst);
      OT_LNG_STRN_POST(cst,argsO);
    }
  } else {
    MK(LngTupleToMkBufferListS) (SETUP_ARGS_CALL, skipP, &retVal);
  }
  *retP = retVal;
  return MK_OK; /* ignore PRE existing ERROR */
error:
  if (retVal && retVal != orig) MkBufferListDelete (retVal);
  *retP = orig;
  return OT_ERROR_STACK;
} 
 
enum MkErrorE MK(CheckBLC) (
  OT_Check_ARGS,
  MK_BFL      *retP,
  bool        nullB
) {
  if ((*skipP) >= objc) {
    WrongNumArgs(hdl, (*skipP), objc, -999, +999, arg);
    goto error;
  }
  MkTestClassE flag;
  MK_OBJ obj;
  OT_OBJ_T objV = OT_LNG_OBJV((*skipP)++);
  if (OT_LNG_OBJ_CLASS_IS_4(objV, OT_OBJ_TO_CLASS(MkBufferListC_lngO), &obj, &flag)) {
    switch (flag) {
      case MkTestClassE_OK                : 
        MK_BFL bfl = MkBfl(obj);
        if (bfl == NULL) SignaturError("MkBufferListC");
        *retP = bfl;
        break;
      case MkTestClassE_NULL              : 
        if (nullB) {
          *retP = NULL;
        } else {
          NullNotAllowd(MkBufferListC_lngO); 
        }
        break;
      case MkTestClassE_INVALID_SIGNATURE : 
        SignaturError("MkBufferListC") ;
      case MkTestClassE_WRONG_CLASS       :
        WrongTypeOfArgError("[array] or MkBufferListC", OT_LNG_OBJ_CLASSNAME(objV));
      case MkTestClassE_NONE_OBJECT       :
      case MkTestClassE_INTERNAL          : 
        InternalError("OT_LNG_OBJECT_IS_3") ;
    }
  } else if (OT_LNG_ARRAY_IS(objV)) {
    MkErrorCheck(MK(LngListToMkBufferListS)(OT_Prefix_CALL objV,retP));
  } else {
    WrongTypeOfArgError("[array] or MkBufferListC", OT_OBJ_TYPE_STRING(objV));
  }
  return MK_OK; /* ignore PRE existing ERROR */
error:
  return OT_ERROR_STACK;
} 
 
#if !defined(NO_OtCheckEnum)
enum MkErrorE MK(CheckEnum) (
  OT_ENUM_T   enumType,
  OT_Check_ARGS,
  int             *retP
)
{
  if ((*skipP) >= objc) {
    WrongNumArgs(hdl, (*skipP), objc, -999, +999, arg);
    goto error;
  }
  OT_OBJ_T objV = OT_LNG_OBJV((*skipP)++);
  if (OT_LNG_I32_IS(objV)) {
    MkErrorCheck(MK(LngObj_AsI32)(OT_Prefix_CALL hdl,objV,retP));
  } else if (OT_LNG_OBJ_ENUM_IS(objV,enumType)) {
    OT_ENUM_TO_I32(objV,enumType); /* keep error for append */
    MkErrorCheck(MK(LngObj_AsI32)(OT_Prefix_CALL hdl,objV,retP));
  } else {
    WrongTypeOfArgError(OT_LNG_ENUM_NAME(enumType), OT_OBJ_TYPE_STRING(objV));
  }
  return MK_OK; /* ignore PRE existing ERROR */
error:
  return OT_ERROR_STACK;
}
#endif // NO_OtCheckEnum
 
#if !defined(NO_OtCheckEnumFlag)
enum MkErrorE MK(CheckEnumFlag) (
  OT_ENUM_T   enumType,
  OT_Check_ARGS,
  int             *retP
)
{
  if ((*skipP) >= objc) {
    WrongNumArgs(hdl, (*skipP), objc, -999, +999, arg);
    goto error;
  }
  OT_OBJ_T objV = OT_LNG_OBJV((*skipP)++);
 
  if (OT_LNG_OBJ_ENUM_IS(objV,enumType)) {
    OT_ENUM_TO_I32(objV,enumType); /* keep error for append */
    MkErrorCheck(MK(LngObj_AsI32)(OT_Prefix_CALL hdl,objV,retP));
  } else {
    WrongTypeOfArgError(OT_LNG_ENUM_NAME(enumType), OT_OBJ_TYPE_STRING(objV));
  }
  return MK_OK; /* ignore PRE existing ERROR */
error:
  return OT_ERROR_STACK;
}
#endif // NO_OtCheckEnumFlag
 
#if !defined(NO_OtCheckTimeT)
enum MkErrorE MK(CheckTimeT) (
  OT_Check_ARGS,
  MK_TIME_T   *retP
) {
  if ((*skipP) >= objc) {
    WrongNumArgs(hdl, (*skipP), objc, -999, +999, arg);
    goto error;
  } 
  OT_OBJ_T objV = OT_LNG_OBJV((*skipP)++);
 
  if (OT_LNG_OBJ_ENUM_IS(objV, OT_OBJ_TO_ENUM(MkTimeoutE))) {
    OT_ENUM_TO_I32_2(objV,MkTimeoutE);  /* keep error for append */
    MkErrorCheck(NS(LngObj_AsLONG)(OT_Prefix_CALL hdl,objV,retP));
  } else if (OT_LNG_LONG_IS(objV)) {
    MkErrorCheck(NS(LngObj_AsLONG)(OT_Prefix_CALL hdl,objV,retP));
  } else if (OT_LNG_OBJECT_IS(objV)) {
    WrongTypeOfArgError("MkTimeoutE", OT_LNG_OBJ_CLASSNAME(objV));
  } else {
    WrongTypeOfArgError("MkTimeoutE", OT_OBJ_TYPE_STRING(objV));
  }
  return MK_OK; /* ignore PRE existing ERROR */
error:
  return OT_ERROR_STACK;
} 
#endif //NO_OtCheckTimeT
 
#if !defined(NO_TestObject)
bool MK(TestObject) (
  OT_Prefix_ARGS
  OT_OBJ_T        lngO,
  OT_CLS_T        typeO,
  MK_OBJ        * objP,
  MkTestClassE  * flagP
) {
  assert(lngO != NULL); 
  assert(typeO != NULL); 
  MkTestClassE flag = MkTestClassE_NONE_OBJECT;
  MK_OBJ obj = NULL;
  if (OT_LNG_IS_NULL(lngO)) { 
    flag=MkTestClassE_NULL; goto end; 
  }
  if (!OT_LNG_OBJ_CLASS_IS(lngO,typeO)) { 
    flag=MkTestClassE_WRONG_CLASS; goto end; 
  }
  MK_MNG      objM = VAL2MNG(lngO);
  if (objM == NULL)   { flag=MkTestClassE_NULL     ; goto end; };
  obj = MkObj(objM);
  if (obj == NULL)    { flag=MkTestClassE_INVALID_SIGNATURE  ; goto end; };
  flag = MkTestClassE_OK;
  if (objP)   *objP = obj;
end:
  if (flagP)  *flagP = flag;
  switch(flag) {
    case MkTestClassE_NONE_OBJECT : return false;
    default                       : return true;
  }
}
#endif //NO_TestObject
 
/*****************************************************************************/
 
#endif