MkExceptionC_PY_API

MkExceptionC - The default-exception of the Programming-Language-Micro-Kernel (PLMK) … More...

Collaboration diagram for MkExceptionC_PY_API:

Functions
void	py_mkkernel_MkExceptionC_Raise (OT_Prefix_ARGS MK_MNGN const expobj, MK_STRN const doc, MK_STRN const callfunc, MK_I32 callline)
	C-API: MkExceptionRaise - convert an MkErrorC into a Target-Programming-Language (TPL) exception …
MK_ERR	py_mkkernel_MkExceptionC_Set (OT_Prefix_ARGS MK_MNG const expobj, MK_EXP const exception, MK_STRN const callfunc)
	C-API: MkExceptionCatch - convert an Target-Programming-Language (TPL) exception into an MkErrorC …

Detailed Description

MkExceptionC - The default-exception of the Programming-Language-Micro-Kernel (PLMK) …

The Programming-Language-Micro-Kernel (PLMK) provide with MkErrorC a complete error-handling with focus to support the "C" Programming-Language. The support include catch, raise, signal and attributes. In addition every Target-Programming-Language (TPL) add their own error-handling and the purpose of MkExceptionC is to integrate the MkErrorC into the Target-Programming-Language (TPL).

The default-exception MkExceptionC is used to connect the MkErrorC with the Target-Programming-Language (TPL) error-object.

• The default-error is defined in MkRuntimeS::error_mk.
• On error the default-error is set to the error-data, the MkErrorE status change to MK_ERROR.
• The non-C language create a copy from the default-error and throw the copy as MkExceptionC exception.
• The C language just return the MkErrorE status of the default-error.

The implementation of an exception depends heavily on the Target-Programming-Language (TPL), starting with no exception at all, for example. C, an exception as a class object, or as an exception as a global attribute.

Attention

• All MkExceptionC code is implemented at the Target-Programming-Language (TPL) without support by the Programming-Language-Micro-Kernel (PLMK) compiler.
• By default, MkExceptionC is only used internally, hidden by the class MkErrorC.

Function Documentation

py_mkkernel_MkExceptionC_Raise()

void py_mkkernel_MkExceptionC_Raise	(	OT_Prefix_ARGS MK_MNGN const	expobj,
		MK_STRN const	doc,
		MK_STRN const	callfunc,
		MK_I32	callline )

C-API: MkExceptionRaise - convert an MkErrorC into a Target-Programming-Language (TPL) exception …

Parameters

[in]	expobj	The LibMsgqueObject used to personalize the exception/error (will be validated first)
[in]	callfunc	a user-defined postfix to identify the calling function or the environment (default=name-of-function)
[in]	callline	the number of the line the call take place (e.g. LINE)
[in]	doc	documentation string

Definition at line 26 of file MkExceptionC_py.c.

{
  PyErr_Clear();
  MK_ERR err = MkErrorFORMAT_1M(expobj);
  MkErrorStackFormat(err,doc,callfunc,callline);
  PyObject *stackO = NULL;   // buffer hold all the current stack frame
  for (int lvl = 0; MK(Get_Call_Stack)(MK_RT_CALL err, lvl, &stackO); lvl++) {
    //printI(lvl);
  }
  Py_CLEAR(stackO); 
  MK_ERR newerr = MkErrCheck(expobj) && expobj != err ? (MK_ERR)expobj : MkErrorDup(err);
  PyObject* errO = OT_TMP_ERR_OBJ(newerr);
  PyErr_SetObject(NS(MkKernelThreadState).MkExceptionC, errO);
  Py_CLEAR(errO);
  // TODO  difference between python and tcl MkErrorReset_1M(expobj) versa MkErrorReset_1(err)
  if (expobj) MkErrorReset_1M(expobj);
}

py_mkkernel_MkExceptionC_Set()

MK_ERR py_mkkernel_MkExceptionC_Set	(	OT_Prefix_ARGS MK_MNG const	expobj,
		MK_EXP const	exception,
		MK_STRN const	callfunc )

C-API: MkExceptionCatch - convert an Target-Programming-Language (TPL) exception into an MkErrorC …

Parameters

[in]	expobj	The LibMsgqueObject used to personalize the exception/error (will be validated first)
[in]	exception	the exception object from Python, if None the global exception object is used
[in]	callfunc	a user-defined postfix to identify the calling function or the environment (default=name-of-function)

Returns

the MkErrorC created with data from exception

Definition at line 51 of file MkExceptionC_py.c.

  {
  //MQ_CTX context = MqCtx(fmtObj);
 
  PyObject *errO = (PyObject*) exception;
 
  MK_ERR err = MkErrorFORMAT_1M(expobj);
  PyObject *typeO = NULL, *valueO=NULL, *tbO = NULL;
 
  if (errO == Py_None || errO == NULL) {
    valueO = PyErr_GetRaisedException();
    if (valueO == NULL) {
      MkErrorSetC(err,"unspecified error",callfunc,1);
      return err;
    }
    typeO = Py_NewRef(Py_TYPE(valueO));
  } else {
    typeO = Py_NewRef(Py_TYPE(errO));
    valueO = Py_NewRef(errO);
  }
  tbO = PyException_GetTraceback(valueO);
 
  {
    PyObject *valO = NULL ;
 
    // step 1. - is it an error?
    if (typeO == Py_None || typeO == NULL) {
      MkErrorSetC (err, "No active exception to reraise", callfunc, -1);
 
    // step 2. - is it an MQ error?
    } else if (PyErr_GivenExceptionMatches(typeO,NS(MkKernelThreadState).MkExceptionC)) {
      MK_ERR newerr = NULL;
      while (true) {
        if (PyObject_TypeCheck(valueO,&NS(MkErrorCR))) {
          newerr = MkErr(((MkErrorC_Obj*)errO)->hdl);
        } else if (PyObject_TypeCheck(valueO,(PyTypeObject*)PyExc_BaseException)) {
          PyObject *tupO = ((PyBaseExceptionObject*)valueO)->args;
          if (tupO == NULL || !PyTuple_Check(tupO)) break;
          PyObject *errO = PyTuple_GetItem(tupO, 0);
          if (errO == NULL) break;
          if (PyObject_TypeCheck(errO,&NS(MkErrorCR))) {
            newerr = MkErr(((MkErrorC_Obj*)errO)->hdl);
          }
        }
        break;
      }
      if (newerr) {
        MkErrorSetE (err, newerr);
      } else {
        MkErrorSetC (err, "No active exception value object to reraise", callfunc, -1);
      }
 
    // step 3. - is it an PYTHON error?
    } else if (valueO) {
      PyObject *tmod = NULL, *strO = NULL, *lstO = NULL;
      LngErrorCheckNT(end1,  tmod = PyImport_ImportModule("traceback"));
      if (tbO) {
        LngErrorCheckNT(end1,  lstO = PyObject_CallMethod(tmod, "format_exception", "OOO", typeO, valueO, tbO));
      } else {
        LngErrorCheckNT(end1,  lstO = PyObject_CallMethod(tmod, "format_exception_only", "OO", typeO, valueO));
      }
      LngErrorCheckNT(end1,  strO = PyC2O(""));
      LngErrorCheckNT(end1,  valO = PyObject_CallMethod(strO, "join", "O", lstO));
end1:
      Py_CLEAR(tmod);
      Py_CLEAR(lstO);
      Py_CLEAR(strO);
      if (valO != NULL && PyUnicode_Check(valO)) {
        PyObject *strO=NULL;
        char *utf8=NULL;
        Py_ssize_t size;
 
        LngErrorCheckNT(end2, strO = PyObject_Str(valO));
        utf8 = (char*)PyUnicode_AsUTF8AndSize(strO,&size);
        if (utf8==NULL) goto end2;
        // delete newline
        if (utf8[size-1]==10) utf8[size-1]=0;
        MkErrorSetC(err, utf8, callfunc, -1);
 
//printXLV(context, "11111 -> MkErrorTLS.server_ctx=%p, MkErrorTLS.client_ctx=%p\n", 
//  MkErrorTLS.server_ctx, MkErrorTLS.client_ctx);
 
end2:
        Py_CLEAR(strO);
      }
      if (MkErrorGetCode_0E() != MK_ERROR)
        MkErrorSetV(err, callfunc, -1, "%s: python error", PyExceptionClass_Name(typeO));
    }
  }
 
  Py_CLEAR(tbO);
  Py_CLEAR(typeO);
  Py_CLEAR(valueO);
  if (PyErr_Occurred()) PyErr_Clear();
  return err;
}