MkExceptionC_py.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#define META_FILE_NAME            "MkExceptionC_py.c"
 
#include "LibMkKernel_private_py.h"
 
/* LABEL-END */
 
 
void NS(MkExceptionC_Raise) (
  OT_Prefix_ARGS
  MK_MNGN const expobj,
  MK_STRN const doc,
  MK_STRN const callfunc,
  MK_I32        callline
)
{
  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);
}
 
MK_ERR NS(MkExceptionC_Catch)(
  OT_Prefix_ARGS
  MK_MNG    const expobj,
  MK_EXP    const exception,
  MK_STRN   const callfunc
) {
  //MQ_CTX context = MqCtx(fmtObj);
 
  PyObject *expO = (PyObject*) exception;
 
  MK_ERR err = MkErrorFORMAT_1M(expobj);
  PyObject *typeO = NULL, *valueO=NULL;
 
  if (expO == Py_None || expO == NULL) {
    valueO = PyErr_GetRaisedException();
    if (valueO == NULL) {
      MkErrorSetC (err, "No active exception to reraise", callfunc, -1);
      return err;
    }
    typeO = Py_NewRef(Py_TYPE(valueO));
  } else {
    typeO = Py_NewRef(Py_TYPE(expO));
    valueO = Py_NewRef(expO);
  }
 
//printLngObj(typeO)
//printLngObj(valueO)
  {
    // 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*)expO)->hdl);
        } else if (PyObject_TypeCheck(valueO,(PyTypeObject*)PyExc_BaseException)) {
          PyObject *tupO = ((PyBaseExceptionObject*)valueO)->args;
          if (tupO == NULL || !PyTuple_Check(tupO)) break;
          PyObject *expO = PyTuple_GetItem(tupO, 0);
          if (expO == NULL) break;
          if (PyObject_TypeCheck(expO,&NS(MkErrorCR))) {
            newerr = MkErr(((MkErrorC_Obj*)expO)->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) {
      OT_OBJ_T errO = OT_TMP_ERR_OBJ(err);
      OT_OBJ_T tstO = PyObject_CallFunction(NS(MkErrorC_FormatException), "OOs", errO, valueO, callfunc);
      if (tstO == NULL) {
        if (PyErr_Occurred()) PyErr_Print();
      } else {
        Py_CLEAR(tstO);
      }
      if (MkErrorGetCode_0E() != MK_ERROR)
        MkErrorSetV(err, callfunc, -1, "%s: python error", PyExceptionClass_Name(typeO));
    }
  }
 
  Py_CLEAR(typeO);
  Py_CLEAR(valueO);
  if (PyErr_Occurred()) PyErr_Clear();
  return err;
}
 
 
// vim: nowrap