MkCall_rb.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
/* LABEL-START */
#define META_FILE_NAME "MkCall_rb.c"
 
#include  "LibMkKernel_private_rb.h"
#include "misc_check_rb.h"
 
/* LABEL-END */
 
mk_inline VALUE NS(sRescue) (
  MK_RT_ARGS
  MK_MNG const mng,
  VALUE(*proc)(ANYARGS),
  VALUE data
) {
  int state;
  VALUE ret = rb_protect(proc, data, &state);
  if (state) {
    OT_ERROR_LNG_2_META_2(mng,"ProcessEvent");
  }
  return ret;
}
 
// ==========================================================================
 
// method callback with ARRAY of args
static VALUE NS(sCallMethod) (VALUE array) {
  const VALUE *valP = rb_array_const_ptr(array);
  return rb_method_call((int)RARRAY_LEN(array)-1, &valP[1], valP[0]);
}
 
// proc callback with ARRAY of args
static VALUE NS(sCallProc) (VALUE array) {
  const VALUE *valP = rb_array_const_ptr(array);
  return rb_proc_call_with_block(valP[0], (int)RARRAY_LEN(array)-1, &valP[1], Qnil);
}
 
enum MkErrorE NS(CheckCallable) (
  OT_Check_ARGS,
  MK_PTR        *retP
) {
  if ((*skipP) >= objc) {
    WrongNumArgs(hdl, (*skipP), objc, -999, +999, arg);
    goto error;
  }
 
  VALUE val = objv[(*skipP)++];
 
  struct MkCallS *call = *retP;
  if (*retP == NULL) {
    call = (struct MkCallS *) MkSysCalloc(MK_ERROR_PANIC,1,sizeof(struct MkCallS));
    call->isAlloc = true;
  }
 
  call->hdl = hdl;
  call->mkrt = MK_RT_PTR;
  call->procArgs = rb_ary_new();
  INCR_REF(&call->procArgs);
 
  if (rb_obj_is_kind_of(val, rb_cMethod) == Qtrue) {
    // val belongs to calling object, but is NOT callable from other
    call->procType    = MkCallS_own_method; 
    call->procCallback    = val;
    INCR_REF(&call->procCallback);
  } else if (rb_obj_is_kind_of(val, rb_cProc) == Qtrue) {
    // val belongs to global proc and is callable from other
    call->procType    = MkCallS_proc; 
    call->procCallback    = val;
    INCR_REF(&call->procCallback);
  } else if (NIL_P(val)) {
    call->procCallback    = Qnil;
  } else if (rb_obj_is_kind_of(val, rb_cUnboundMethod) == Qtrue) {
    // val belongs to calling object, but is NOT callable from other
    call->procType    = MkCallS_unbound_method; 
    call->procCallback    = val;
    INCR_REF(&call->procCallback);
  } else if (rb_obj_is_kind_of(val, rb_cString) == Qtrue) {
    const MkStringR tmp = VAL2MkStringR(val);
    if (MkStringIsNULL(tmp)) {
      call->procCallback  = Qnil;
    } else {
      WrongCallableError(tmp.ptr);
      goto error;
    }
  } else {
    WrongCallableError(OT_OBJ_TYPE_STRING(val));
    goto error;
  }
 
  if (call->procCallback == Qnil) {
    DECR_REF(&call->procArgs);
    call->procArgs = Qnil;
    if ( call->isAlloc ) MkSysFree(call);
    *retP = NULL;
  } else {
    call->procArity = VAL2I32(rb_funcallv(call->procCallback,NS(id_arity),0,NULL));
    *retP = call;
  }
  return MK_OK;
error:
  return OT_ERROR_STACK;
}
 
// cleanup call->procCallback from above
void NS(CallFree) (MK_PTR* callP) {
  // BUG FIX → ruby crash on object allocation during GC at "Nhi1Exec Bug3.rb".
  // The crash accourse because of GC is active after a raise of an error at constructor AND
  // the service-callback is deleted in "DECR_REG" which create a NEW object in "rb_ary_delete" !!
  // if (callP == NULL || *callP == NULL || rb_during_gc() ) return;
  if (callP == NULL || *callP == NULL ) return;
  struct MkCallS *call = (struct MkCallS*) *callP;
  if (!OT_LNG_NULL_IS(call->procCallback)) {
    DECR_REF(&call->procCallback);
    call->procCallback = Qnil;
  }
  if (!OT_LNG_NULL_IS(call->procArgs)) {
    DECR_REF(&call->procArgs);
    call->procArgs = Qnil;
  }
//printV("call=%p, data=%p\n", call, call->procCallback)
  if (call->isAlloc)  MkSysFree(*callP); 
  else                *callP = NULL;
}
 
void MK(CallFreeOnce) ( MK_CBP *callP )
{
  MK(CallFree) (callP);
}
 
 
// *********************************************************************
 
/*
[ObjectDeleteCall signature]
  callback-args := typeName:MK_STRN[in], typeHdl:MK_HDL[in], objHdl:MK_HDL[in]
  [static]   def callback ( callback-args )
  [instance] class YYY
               def callback ( callback-args )
  [class]    class ZZZ 
               def self.callback ( callback-args )
[ObjectDeleteCall signature]
*/
 
enum MkErrorE
NS(ObjectDeleteCall) ( MkObjectDeleteCallF_ARGS )
{
  MkObjectDeleteCallF_CHECK;
 
  // if NO self object is available than NO callback is called
  if (!MkSelfExists(obj)) return MK_OK;
 
  struct MkCallS *call = __data__;
  int argNum = 3;
 
  rb_set_errinfo(Qnil);
 
  // 1. check environment
  if (OT_LNG_NULL_IS(call->procCallback)) return MK_OK;
 
  // 2. if not already done initialize
  if (call->procCall == NULL) {
    switch (call->procType) {
      case MkCallS_own_method: {
        call->procCall = NS(sCallMethod);
        if (argNum != call->procArity) goto methode_arg_error;
      }
      break;
      case MkCallS_proc:
        call->procCall = NS(sCallProc);
        if (argNum != call->procArity) goto methode_arg_error;
      break;
      default:
        MkErrorSetV_3M(obj, "WrongInitError", "found invalid procType for callback '%s'", VAL2STRN(call->procCallback));
        goto error;
      break;
    }
  }
 
  // 3. call callback
  VALUE ary = rb_ary_resize(call->procArgs,4);
  rb_ary_store(ary,0,call->procCallback);
  rb_ary_store(ary,1,STRN2VAL(typeName));
  rb_ary_store(ary,2,HDL2VAL(typeHdl));
  rb_ary_store(ary,3,HDL2VAL(objHdl));
  // info: https://docs.ruby-lang.org/en/master/extension_rdoc.html#label-Appendix+E.+RB_GC_GUARD+to+protect+from+premature+GC
  NS(sRescue)(MK_RT_CALL call->hdl,call->procCall,ary);
  MkErrorCheck_0E();
  return MkErrorGetCode_0E();
 
methode_arg_error:
  MkErrorSetV_3M(obj, "WrongNumberOfArgError", 
    "for callback '%s' exactly '%d' argument is required, but '%d' was received", 
      VAL2STRN(call->procCallback), argNum, call->procArity);
  goto error;
 
error:
MkDbgDeepX_3(mqctx, "EEE", "cmd=%s", VAL2STRN(rb_inspect(call->procCallback)));
  return MkErrorStack_0E();
}
 
void NS(ObjectDeleteFree) ( MkObjectDeleteFreeF_ARGS )
{
  MK(CallFree)(dataP);
}