high_lng.h

Go to the documentation of this file.

 
// internal usage -> PERL pre-parse (./perl_MqS.tcl) need this
// Problem: PERL include CPP preprocessed data into the ".xsh" file but preprocessing require all
//          macros set.
// Default: original in msgque_mq.h
#if MQ_PRE_PARSE
  #define MkBufferListCreateTLS(name,num)                        \
    static MkThreadLocal struct MkBufferListS __##name = {0};    \
    MK_BFL name = &__##name;                                  \
    if (likely(__MqBflCheck(__##name))) {                     \
      MkBufferListReserve(name,num);                             \
    } else {                                                  \
      MkBufferListInit(name,num);                                \
      MkRefIncr(name);                                        \
    }
#endif
 
/*
 
highSKIP_SHIFT ...  calculate argument position from array index
      example:      Send(             callSig, ARRAY  ...)
                    SKIP                       0,     ...
                                      Arg-1    Arg-2, ...
                    highSKIP_SHIFT =  1        + 1        = 2
 
highLastReturnListType ... get the last ONE CHAR signature type of the read-token.
                           -> the reason is a non-symmetric behaviour of the MkBufferS.
                           Every OTHER type can be stored into a MkBufferS but NOT the MkBufferS
                           self. the 'U' ONE CHAR signature have to be remembert if the user explicit
                           require a 'U' as return and NOT the 'U' internal data-type.
 
EXAMPLE use of highLastReturnListType in "highRETURN_type_S"
*/
 
#define HighErrorV(cls,fmt,args...) \
  MkErrorSetV_3M(obj, cls, fmt, args)
 
#define HighErrorC(cls,fmt) \
  MkErrorSetV_3M(obj, cls, "%s", fmt)
 
#define highRETURN_type_S                                                        \
  if (MkBufferListSizeI(RET) == 0 && highLastReturnListType != '*') {            \
    OT_retObj_SET_None;                                                          \
  } else if (MkBufferListSizeI(RET) == 1 && highLastReturnListType != '*' ) {    \
    switch (highLastReturnListType) {                                            \
      case 'U': OT_retObj_SET_BUF(RET->data[0]); break;                          \
/* >>>> disable MkBufferListReserve at startup from Send <<<< */                 \
/* OLD !! BUG FIX: high2-1-2-U-O-*                              */               \
/* Return 'U' without 'Temp'orary object make return UNUSEABLE  */               \
/* as input for an other "Send", because "MkBufferListCreateTLS"   */            \
/* reset the return "U"                                         */               \
/*    SEND_ONE_TYP_O {                                          */               \
/*      set t [$ctx ReadSTR]                                      */             \
/*      set RET [$ctx Send "W" "ECOA:$t@$t" [$ctx Read$t]]      */               \
/*      $ctx Send "R" $t $RET                                   */               \
/*    }                                                         */               \
/* => "RET" is broken WITHOUT "temp"                            */               \
/*    case 'U': OT_MK_CALL_0(RET->data[0],MkBufferC,Temp,retObj); break;  */     \
      case 'L': OT_MK_CALL_0(RET->data[0],MkBufferC,GetBFL,retObj); break;       \
      default : OT_MK_CALL_0(RET->data[0],MkBufferC,ToObject,retObj); break;     \
    }                                                                            \
  } else {                                                                       \
    OT_retObj_SET_BFL(RET);                                                      \
  }                                                                                                                
 
#define high_3_O  BOL
#define high_3_Y  I8
#define high_3_S  I16
#define high_3_I  I32
#define high_3_W  I64
#define high_3_H  HDL
#define high_3_F  FLT
#define high_3_D  DBL
#define high_3_C  STRN
#define high_3_B  BIN
#define high_3_U  BUF
#define high_3_L  BFL
#define high_3_A  BAC
 
#define  high_C_BOL  OT_TMP_BOL_OBJ
#define  high_C_I8   OT_TMP_I8_OBJ
#define  high_C_I16  OT_TMP_I16_OBJ
#define  high_C_I32  OT_TMP_I32_OBJ
#define  high_C_I64  OT_TMP_I64_OBJ
#define  high_C_H    OT_TMP_HDL_OBJ
#define  high_C_FLT  OT_TMP_FLT_OBJ
#define  high_C_DBL  OT_TMP_DBL_OBJ
#define  high_C_STR  OT_TMP_CST_OBJ
#define  high_C_BIN  OT_TMP_BIN_OBJ
#define  high_C_BUF  OT_TMP_BUF_OBJ
#define  high_C_BFL  OT_TMP_BFL_OBJ
#define  high_C_A    OT_TMP_BAC_OBJ
 
#define high_T_BOL  MK_BOL
#define high_T_I8   MK_I8
#define high_T_I16  MK_I16
#define high_T_I32  MK_I32
#define high_T_I64  MK_I64
#define high_T_HDL  MK_HDL
#define high_T_FLT  MK_FLT
#define high_T_DBL  MK_DBL
#define high_T_STR  MK_STRN
#if !defined(high_T_BIN)
  #define high_T_BIN  MK_BIN
#endif
#if !defined(high_T_BUF)
  #define high_T_BUF  MK_BUF
#endif
#if !defined(high_T_BFL)
  #define high_T_BFL  MK_BFL
#endif
#if !defined(high_T_A)
  #define high_T_A  MK_BAC
#endif
#if !defined(MqReadA)
  #define MqReadA MqReadALL
#endif
 
// SPLIT *********************************************************************************************
  static MK_STRN  unknown   = "unknown";
  MK_STRN         block     = unknown;
  MK_STRN         callSig   = unknown;
  MK_STRN         ptr       = "";
  MK_STRB         srvSig[MQ_SEND_TRANSACTION_TOKEN_SIZE+1] = "unknown";
  MK_STRB         tokSig[MQ_SEND_TOKEN_SIGNATURE_SIZE+1] = "unknown";
  MK_TIME_T       timeout   = MK_TIMEOUT_USER;
  bool            Tstart    = false;
  bool            Lstart    = false;
  MK_OBJ const    obj       = MkOBJ(mqctx);
  bool            rpc       = false;
 
#if highSIZE_AVAILABLE==0
#if !defined(highSIZE)
  # define highSIZE highSKIP+1
#endif
#endif
 
#if highREAD_RETURN_LIST==1
  __attribute__((unused)) MK_STRB highLastReturnListType = '\0';
  // disable MkBufferListReserve temporary - the FIRST argument '->data[0]' is the return value
  // of an previous 'Send(...' -> on a MkBufferListReserve the previous return will be destroyed.
  #define MkBufferListReserve_RT(...)
  MkBufferListCreateTLS_T(RET,5);
  #undef  MkBufferListReserve_RT
#endif
 
#if defined(compile_as_cc_method)
try {
#endif
 
  //++MkErrorReset(mqctx);
 
  enum MqCallE {
    MQ_ONCE ,   
    MQ_WAIT ,   
    MQ_SUB  ,   
    MQ_CB   ,   
    MQ_TRAN ,   
    MQ_RET      
  } call = MQ_ONCE;
 
  // step 1. -> read the CALL-Identifer
  block = "CALL";
  highINITcstr;
  callSig = cstr;
 
  for (ptr=cstr; *ptr != '\0'; ptr++) {
    switch (*ptr) {
      case 'E': call = MQ_ONCE    ;timeout=0                      ; continue;
      case 'W': call = MQ_WAIT                                    ; continue;
      case 'R': call = MQ_RET     ;timeout=0                      ; continue;
    }
#if highSIZE_AVAILABLE
    if (highSKIP >= highSIZE) {
      HighErrorV("ArgumentListSizeError", "require %d have %d for item '%c'",
                    (int)highSKIP+highSKIP_SHIFT,(int)highSIZE,*ptr);
      goto error;
    }
#endif
    switch (*ptr) {
      case 'S': call = MQ_SUB                 ;highCALL(fCall)    ; 
        if (fCall==NULL) {
          HighErrorC("SubError", "expect a FUNCTION pointer, but got 'NULL'");
          goto error;
        }
        break;
      case 'C': call = MQ_CB      ;timeout=0  ;highCALL(fCall)    ; 
        if (fCall==NULL) {
          HighErrorC("CallbackError", "expect a FUNCTION pointer, but got 'NULL'");
          goto error;
        }
        break;
      case 'T': call = MQ_TRAN                ;highTRAN(srvSig)   ;
        srvSig[MQ_SEND_TRANSACTION_TOKEN_SIZE] = '\0';
        if (strlen(srvSig) != 4) {
          HighErrorC("TokenError", "expect a '4' character string as a TRANSACTION-identifier");
          goto error;
        }
        break;
      case 't': highTIME(timeout)                                 ;
        break;
      case 'r': rpc = true                                        ;
        break;
      default: {
        HighErrorV("Error", "invalid character '%c' found", *ptr);
        goto error;
      }
    }
  }
 
  // step 2. -> build the Send-Data-Package
 
  block = "TOKEN";
//printV("highSKIP<%d>, highSIZE<%d>\n", highSKIP, highSIZE)
  if (call == MQ_RET && highSKIP == highSIZE) goto call;
  highTOKEN(tokSig);
  tokSig[MQ_SEND_TOKEN_SIGNATURE_SIZE] = '\0';
  ptr = cstr = tokSig;
  MkErrorCheck(MqSendSTART(mqctx));
 
  MK_STRB token[9];
  if (call == MQ_RET) {
    token[0] = '\0';
    if (tokSig[0] == ':') ptr+=1;  // 1char ':' optional
  } else {
    size_t const toklen = strlen(tokSig);
    if (rpc) {
      MK_STRN end = strpbrk(ptr,":@");
      size_t tlen = end ? (size_t) (end-ptr) : toklen;
      strncpy(token,MkSysHashSTR(ptr,(MK_NUM)tlen),8);
      token[8] = '\0';
      ptr+=tlen;
    } else if (toklen >= 4 && (tokSig[4] == ':' || tokSig[4] == '@' || tokSig[4] == '\0')) {
      strncpy(token,tokSig,4);
      token[4] = '\0';
      ptr+=4;
    } else if (toklen >= 8 && (tokSig[8] == ':' || tokSig[8] == '@' || tokSig[8] == '\0')) {
      strncpy(token,tokSig,8);
      token[8] = '\0';
      ptr+=8;
    } else {
      HighErrorV("TokenError", "expect token as string of size 4 or as hex-string of size 8 but got '%s'", tokSig);
      goto error;
    }
//printLV("token<%s>, cstr<%s>, tokSig<%s>\n", token, cstr, tokSig);
    if (*ptr != '\0' && *ptr != '@') {
      if (*ptr != ':' && *ptr != '\0') {
        HighErrorV("TokenError", "expect ':' character but got '%c' character", *ptr);
        goto error;
      }
      ptr+=1;  // 4char 'TOKEN' + 1char ':'
    }
  }
 
  for (; *ptr != '\0'; ptr++) {
    switch (*ptr) {
      case '[': 
        Lstart = true;
        MkErrorCheck (MqSendL_START (mqctx))  ; 
        continue;
      case ']': 
        if (Lstart == false) {
          HighErrorC("SendError", "missing opening '[' to closing ']'");
          goto error;
        } else {
          MkErrorCheck (MqSendL_END (mqctx))  ; 
        }
        continue;
      case '(': 
        if (call != MQ_TRAN) {
          HighErrorV("SendError", "'(' invalid for CALL-signature '%s'", callSig);
          goto error;
        } else {
          Tstart = true;
          MkErrorCheck (MqSendT_START (mqctx))  ; 
        }
        continue;
      case ')':
        if (call != MQ_TRAN) {
          HighErrorV("SendError", "')' invalid for CALL-signature '%s'", callSig);
          goto error;
        } else if (Tstart == false) {
          HighErrorV("SendError", "missing opening '(' to closing ')' for CALL-signature '%s'", callSig);
          goto error;
        } else {
          MkErrorCheck (MqSendT_END (mqctx))  ; 
        }
        continue;
      case '@': goto call;
    }
 
#if highSIZE_AVAILABLE==1
    if (highSKIP >= highSIZE) {
      HighErrorV("ArgumentListSizeError", "require %d have %d for item '%c'",
                    (int)highSKIP+highSKIP_SHIFT,(int)highSIZE,*ptr);
      goto error;
    }
#endif
 
    switch (*ptr) {
      case 'Y': highSend_I8;break;
      case 'O': highSend_BOL;break;
      case 'S': highSend_I16;break;
      case 'I': highSend_I32;break;
      case 'F': highSend_FLT;break;
      case 'W': highSend_I64;break;
      case 'D': highSend_DBL;break;
      case 'C': highSend_STR;break;
      case 'U': highSend_BUF;break;
      case 'L': highSend_BFL;break;
      case 'B': highSend_BIN;break;
#if NHI1_bits == 64
      case 'G': highSend_I64;break;
#elif NHI1_bits == 32
      case 'G': highSend_I32;break;
#else
# error "'wordsize' cannot be recognized because 'NHI1_bits' is not set. probably missing the header 'nhi1_config.h' ?"
#endif
      case 'H': highSend_HDL;break;
      default:
        HighErrorV("SendError","invalid character '%c' found", *ptr);
        goto error;
    }
  }
 
call:
  // check # return-args
  if (timeout == 0 && (*ptr) == '@' && (*(ptr+1)) != '\0') {
    ptr++;
    MkErrorSetV_4M(obj, "CallError", 0, "got RETURN args for NON-RETURN CALL-signature '%s'", callSig );
    goto error;
  }
#if highSIZE_AVAILABLE==1
  if ((*ptr) == '\0' && highSKIP < highSIZE) {
    HighErrorV("ArgumentError","found '%d' argument(s) more than needed", (int)(highSIZE-highSKIP));
    goto error;
  }
#endif
 
  // do the service call
  switch (call) {
    case MQ_ONCE:
      MkErrorCheck( MqSendEND( mqctx, token, timeout ) );
      break;
    case MQ_WAIT:
      MkErrorCheck( MqSendEND_AND_WAIT( mqctx, token, timeout ) );
      break;
    case MQ_SUB:
      MkErrorCheck( MqSendEND_AND_SUB( mqctx, token, highFARGS(fCall), timeout ) );
      break;
    case MQ_CB:
      MkErrorCheck( MqSendEND_AND_CALLBACK( mqctx, token, highFARGS(fCall), timeout ) );
      break;
    case MQ_TRAN:
      MkErrorCheck( MqSendEND_AND_TRANSACTION( mqctx, token, srvSig, timeout) );
      break;
    case MQ_RET:
      MkErrorCheck( MqSendRETURN( mqctx ) );
      break;
  }
 
  highREADprepare
#if highREAD_RETURN_LIST==1
  MkBufferListReserve(RET,MqReadGetNumItems(mqctx) + highSKIP - highSIZE);
#endif
  if (*ptr != '\0') {
    for (ptr++; *ptr != '\0'; ptr++) {
      highREADinit;
      if (highSKIP >= highSIZE) {
#if highREAD_RETURN_LIST==0
        HighErrorV("ArgumentListSizeError","require %d have %d - missing argument for item '%c'",
                (int)highSKIP+highSKIP_SHIFT, (int)highSIZE, *ptr);
        goto error;
#else
        if (MqReadGetNumItems(mqctx) <= 0 && *ptr != '*') {
          HighErrorV("PackageSizeError","missing package-item(s) for format-string '%s'", ptr);
          goto error;
        }
        enum MkTypeE target;
        highLastReturnListType = *ptr;
        // target support: highREAD_RETURN_LIST
        switch (*ptr) {
          case 'Y': target=MK_I8T; goto native;
          case 'O': target=MK_BOLT; goto native;
          case 'S': target=MK_I16T; goto native;
          case 'I': target=MK_I32T; goto native;
          case 'F': target=MK_FLTT; goto native;
          case 'W': target=MK_I64T; goto native;
          case 'D': target=MK_DBLT; goto native;
#if NHI1_bits == 64
          case 'G': target=MK_I64T; goto native;
#else
          case 'G': target=MK_I32T; goto native;
#endif
          case 'H': target=MK_HDLT; goto native;
native:   {
            MK_BUF buf;
            MqReadBUF_E(mqctx,&buf);
            if (buf->var.type == MK_STRT) {
              buf = MkBufferTemp(buf);
              MkBufferCastTo_E(buf,target);
            } else if (buf->var.type != target) {
              HighErrorV("ReturnTypeError#1","require '%c' but have '%c'", *ptr, MkBufferGetType1(buf));
              goto error;
            }
            MkBufferListAppendBUF(RET,buf);
            break;
          }
          case 'C':
          case 'L':
          case 'B': {
            MK_BUF buf;
            MqReadBUF_E(mqctx,&buf);
            if (MkBufferGetType1(buf) != *ptr) {
              HighErrorV("ReturnTypeError#2","require '%c' but have '%c'", *ptr, MkBufferGetType1(buf));
              goto error;
 
            }
            MkBufferListAppendBUF(RET,buf);
            break;
          }
          case '.': 
          case 'U': {
            MK_BUF buf;
            MqReadBUF_E(mqctx,&buf);
            MkBufferListAppendBUF(RET,buf);
            break;
          }
          case '*': {
            MqReadALL_E(mqctx, &RET);
            break;
          }
          case '[': MkErrorCheck(MqReadL_START  (mqctx,NULL)  );     break;
          case ']': MkErrorCheck(MqReadL_END    (mqctx)       );     break;  
          case '(': 
          case ')': {
            HighErrorV("ReadError","special character '%c' not supported for RETURN-LIST type", *ptr);
            goto error;
          }
          default: {
            HighErrorV("ReadError","invalid character '%c' found", *ptr);
            goto error;
          }
        }
#endif
      } else {
        switch (*ptr) {
#if highREAD_HAS_REFERENCE==1
          case 'Y': highReadRef_I8;break;
          case 'O': highReadRef_BOL;break;
          case 'S': highReadRef_I16;break;
          case 'I': highReadRef_I32;break;
          case 'F': highReadRef_FLT;break;
          case 'W': highReadRef_I64;break;
          case 'D': highReadRef_DBL;break;
          case 'C': highReadRef_STR;break;
          case 'U': highReadRef_BUF;break;
          case 'L': highReadRef_BFL;break;
          case 'B': highReadRef_BIN;break;
          case '*': highReadRef_ARGS;break;
#endif
          case '[': MkErrorCheck(MqReadL_START  (mqctx,NULL)  );     break;
          case ']': MkErrorCheck(MqReadL_END    (mqctx)       );     break;  
          case '(': MkErrorCheck(MqReadT_START  (mqctx)       );     break;  
          case ')': MkErrorCheck(MqReadT_END    (mqctx)       );     break;  
          default: {
            HighErrorV("ReadError","invalid character '%c' found", *ptr);
            goto error;
          }
        }
      }
    }
  }
 
#if highSIZE_AVAILABLE==1
  if (highSKIP < highSIZE) {
    MkErrorSetV_4M(obj,"ArgumentListSizeError",-1, 
      "found more arguments '%d' as required '%d' at %s-signature '%s'",
          (int)highSIZE, (int)highSKIP+highSKIP_SHIFT, block,cstr);
    goto error;
  }
#endif
 
  highRETURN;
  highRETok;
error:
#if defined(compile_as_cc_method)
  // C++ -> FIRST raise
  MkExceptionC::Raise(MkOBJ(mqctx));
} catch (const std::exception& e) {
   // C++ -> CATCH the FIRST raise AND everything wich was NOT raised by MQ
//printV("fmtobj<%p>, fmtobj->objRt<%p>, MkRT<%p>", MkOBJ(mqctx), MkOBJ(mqctx)->objRt, MkRT);
  //MkErrorC::DEFAULT()->Catch(e);
  MkErrorC::FORMAT(MkOBJ(mqctx))->Catch(e);
#endif
  highERRORnative;
  MkBufferSetV(&mqctx->ctxbuf.super.buf, highCMD, highSELF, callSig, tokSig);
  MkErrorStack_4M(obj, mqctx->ctxbuf.super.buf.storage.first.C, __FILE__, __LINE__);
  if ((int)(ptr-cstr) > (int)strlen(cstr)) block = unknown;
  //if (block != unknown) {
  if (strcmp(block,"unknown")!=0) {
    if ((int)(ptr-cstr) == (int)strlen(cstr)) 
      MkErrorAppendV_2M(obj,"  -> found on %s-SIGNATUR '%s'", block, cstr);
    else if (*ptr != '@')
      MkErrorAppendV_2M(obj,"  -> found on CHARACTER '%c' at POSITION '" MK_FORMAT_Z "' of %s-SIGNATURE '%s'", 
        *ptr, (ptr-cstr)+1, block, cstr);
  }
#if defined(compile_as_cc_method)
}
#endif
  // C++ -> SECOND raise
  highRETerror;
// ********************************************************************************************
 
// vim: nowrap