Sq3ValueC_py.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define META_FILE_NAME              "Sq3ValueC_py.c"
 
#include "LibSq3Lite_private_py.h"
 
// PY class
#define OT_CLASS                    (&NS(Sq3ValueCR))
#define OT_CLASS_NAME               "Sq3ValueC"
 
#define OT_LNG2META(O)              Sq3Val(VAL2MNG(O))
 
#define OT_retObj_CONSTR(mng)       OT_retObj_SET(NS(Sq3ValueC_CTOR)(MK_RT_CALL (PyTypeObject*)class,mng))
 
#define OT_SETUP_hdl                OT_SETUP_hdl_tmpl(Sq3ValueC)
#define OT_SETUP_hdl__null_allow    OT_SETUP_hdl_tmpl__null_allow(Sq3ValueC)
#define OT_SETUP_hdl_constr         MK_RT_UNUSED AllRtSetup_NULL; \
                                    SQ3_VAL hdl = (SQ3_VAL) OT_CLASS;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(Sq3ValueC)
#define OT_SETUP_hdl_static         MK_RT_UNUSED AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = Sq3ValueC##_TT;
 
#define OT_SETUP_hdl_static_constr  OT_SETUP_hdl_static
 
#if !defined(SetupRtFromObj_X)
  #define SetupRtFromObj_X(hdl)     AllRtSetup_X(hdl)
  #define SetupRtFromObj_XN(hdl)    AllRtSetup_XN(hdl)
#endif
 
// MO class
#undef Sq3ValueCTT
#define Sq3ValueCTT SQ3(Sq3LiteThreadState).Sq3ValueCTT
/* Sq3ValueC_MK_NULL defined in LibSq3Lite_py.h */
 
__attribute__((unused)) mk_inline
OT_OBJ_T NS(Sq3ValueC_CTOR) (MK_RT_ARGS OT_CLS_T type, SQ3_VAL hdl) {
  return MK(AtomCreate)(MK_RT_CALL type,Sq3ValueC_X2obj(hdl));
}
 
// helper: mk_dbg_color_ln(MK_COLOR_YELLOW,"hdl<%p>, self<%p>", obj, self);
 
// META: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
static MK_PTR NS(Sq3ValueC_selfCreate) (MK_RT_ARGS MK_OBJ const obj, MK_PTR const env) {
  return MK(AtomCreate) (MK_RT_CALL OT_CLASS,obj);
}
// META: called if MkObj must be destroyed and if the SELF is still alive → goal: destroy the SELF
static void NS(Sq3ValueC_selfDelete) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MK(AtomDeleteHard) (MK_RT_CALL OT_SELF);
}
// META: called to destroy link from SELF to META
static void NS(Sq3ValueC_selfUnlink) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MkObjectC_Obj *selfO = (MkObjectC_Obj*) self;
  selfO->hdl = NULL;
}
 
// initialize the PY and MO class specific object
#define   ClassInit \
  /* if not already done, initialize NEW META type */ \
  if (Sq3ValueCTT == NULL) Sq3ValueCTT = Sq3ValueSTT; \
  \
  /* protect against double call */ \
  if (Sq3ValueCTT->selfCreate == NS(Sq3ValueC_selfCreate)) return MK_OK; \
  \
  /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
  Sq3ValueCTT->selfCreate    = NS(Sq3ValueC_selfCreate); \
  Sq3ValueCTT->selfDelete    = NS(Sq3ValueC_selfDelete); \
  Sq3ValueCTT->selfUnlink    = NS(Sq3ValueC_selfUnlink); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
    NS(Sq3ValueCR).tp_base = Sq3ValueC_base; \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "Sq3ValueC", (PyObject *)OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  Sq3ValueC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/));
 
/* LABEL-END */
 
#define META_CONTEXT_S        MK_ERROR_DEFAULT
 
// MARK_D
 
// BEGIN-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// doc-key: Sq3ValueC,Sq3Value,sc_,func
#define GetNull_doc "Sq3ValueC Sq3ValueC.GetNull()"
#define HandleResolve_doc "Sq3ValueC Sq3ValueC.HandleResolve(netHdl:MK_HDL)"
#define Instances_doc "Sq3ValueC Sq3ValueC.Instances()"
 
// doc-key: Sq3ValueC,Sq3Value,oCx,func
#define Dup_doc "Sq3ValueC sq3val.Dup() (const)"
 
// doc-key: Sq3ValueC,Sq3Value,oc_,func
#define BUF_doc "MkBufferC val.BUF() (const)"
#define Blob_doc "MkBufferC sq3val.Blob() (const)"
#define Next_doc "Sq3ValueC val.Next()"
#define Prev_doc "Sq3ValueC val.Prev()"
 
// doc-key: Sq3ValueC,Sq3Value,oco,func
#define VtabInFirst_doc "Sq3ValueC pVal.VtabInFirst()"
#define VtabInNext_doc "Sq3ValueC pVal.VtabInNext()"
 
// doc-key: Sq3ValueC,Sq3Value,om_,func
#define BinaryR_doc "binary sq3val.BinaryR() (const)"
#define Bytes_doc "Sq3TextE sq3val.Bytes() (const)"
#define Double_doc "double sq3val.Double() (const)"
#define Encoding_doc "Sq3TextE sq3val.Encoding() (const)"
#define FromBind_doc "bool sq3val.FromBind() (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
#define Int_doc "int32 sq3val.Int() (const)"
#define Int64_doc "int64 sq3val.Int64() (const)"
// skip class-overload: Log → MkObjectLog
#define NoChange_doc "bool sq3val.NoChange() (const)"
#define NumericType_doc "Sq3TypeE sq3val.NumericType() (const)"
#define StringR_doc "string sq3val.StringR() (const)"
#define SubType_doc "int32 sq3val.SubType() (const)"
#define Text_doc "string sq3val.Text() (const)"
#define Type_doc "Sq3TypeE sq3val.Type() (const)"
 
// END-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// MARK_M
 
// BEGIN-Sq3ValueC - created by 'py_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
 
// doc-key: Sq3ValueC,Sq3ValueC-Class-Export,sc_
 
static OT_ProcRet NS(Sq3ValueC_HandleResolve) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(HandleResolve_doc);
  MK_HDL netHdl = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIH (netHdl))
  OT_CHECK_NOARGS;
  SQ3_VAL retVal = Sq3ValueHandleResolve (netHdl);
  OT_retObj_SET_VAL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: Sq3ValueC,Sq3ValueC-Class-Export,om_
 
// skip on class-overload: Sq3ValueHandleGet → MkObjectHandleGet
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(Sq3ValueC_HandleGet) (Sq3ValueC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// Sq3ValueC_Class_PY_API
 
 
// doc-key: Sq3ValueC,Sq3ValueC-Class-Introspection,oc_
 
static OT_ProcRet NS(Sq3ValueC_Next) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  SQ3_VAL retVal = Sq3ValueNext (hdl);
  OT_retObj_SET_VAL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_Prev) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  SQ3_VAL retVal = Sq3ValuePrev (hdl);
  OT_retObj_SET_VAL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: Sq3ValueC,Sq3ValueC-Class-Introspection,sc_
 
static OT_ProcRet NS(Sq3ValueC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  SQ3_VAL retVal = Sq3ValueInstances ();
  OT_retObj_SET_VAL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// Sq3ValueC_Class_PY_API
 
 
// doc-key: Sq3ValueC,Sq3ValueC-Class-Misc,sc_
 
static OT_ProcRet NS(Sq3ValueC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  SQ3_VAL retVal = Sq3ValueGetNull ();
  OT_retObj_SET_VAL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// Sq3ValueC_Class_PY_API
 
 
// doc-key: Sq3ValueC,Sq3ValueC-Info,om_
 
static OT_ProcRet NS(Sq3ValueC_Bytes) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Bytes_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Sq3_enum_OBJ(TextE,Sq3ValueBytes (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_Encoding) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Encoding_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Sq3_enum_OBJ(TextE,Sq3ValueEncoding (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_FromBind) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(FromBind_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(Sq3ValueFromBind (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// skip on class-overload: Sq3ValueLog → MkObjectLog
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(Sq3ValueC_Log) (Sq3ValueC_ARGS) {OT_ERROR_LNG_RETURN;}
 
static OT_ProcRet NS(Sq3ValueC_NoChange) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(NoChange_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(Sq3ValueNoChange (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_NumericType) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(NumericType_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Sq3_enum_OBJ(TypeE,Sq3ValueNumericType (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_SubType) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SubType_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(Sq3ValueSubType (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_Type) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Type_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Sq3_enum_OBJ(TypeE,Sq3ValueType (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// Sq3ValueC_Info_PY_API
 
 
// doc-key: Sq3ValueC,Sq3ValueC-TOR,oCx
 
static OT_ProcRet NS(Sq3ValueC_Dup) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Dup_doc);
  OT_CHECK_NOARGS;
  SQ3_VAL retVal = Sq3ValueDup (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(Sq3ValueC);
    goto error;
  }
  OT_retObj_SET_VAL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// Sq3ValueC_TOR_PY_API
 
 
// doc-key: Sq3ValueC,Sq3ValueC-Types,oc_
 
static OT_ProcRet NS(Sq3ValueC_BUF) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(BUF_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = Sq3ValueBUF (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_Blob) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Blob_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = Sq3ValueBlob (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: Sq3ValueC,Sq3ValueC-Types,om_
 
static OT_ProcRet NS(Sq3ValueC_BinaryR) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(BinaryR_doc);
  OT_CHECK_NOARGS;
  MkBinaryR retVal = Sq3ValueBinaryR (hdl);
  OT_retObj_SET(OT_GET__ME_REF_MkBinaryR(retVal));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_Double) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Double_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_DBL(Sq3ValueDouble (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_Int) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Int_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(Sq3ValueInt (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_Int64) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Int64_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I64(Sq3ValueInt64 (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_StringR) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(StringR_doc);
  OT_CHECK_NOARGS;
  MkStringR retVal = Sq3ValueStringR (hdl);
  OT_retObj_SET(OT_GET__ME_REF_MkStringR(retVal));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_Text) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Text_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(Sq3ValueText (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// Sq3ValueC_Types_PY_API
 
 
// doc-key: Sq3ValueC,Sq3ValueC-Vtab,oco
 
static OT_ProcRet NS(Sq3ValueC_VtabInFirst) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(VtabInFirst_doc);
  OT_CHECK_NOARGS;
  SQ3_VAL ppOut;
  MkErrorC_Check(hdl,Sq3ValueVtabInFirst (hdl, &ppOut));
  OT_retObj_SET_VAL(ppOut);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(Sq3ValueC_VtabInNext) (Sq3ValueC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(VtabInNext_doc);
  OT_CHECK_NOARGS;
  SQ3_VAL ppOut;
  MkErrorC_Check(hdl,Sq3ValueVtabInNext (hdl, &ppOut));
  OT_retObj_SET_VAL(ppOut);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// Sq3ValueC_Vtab_PY_API
 
// END-Sq3ValueC - created by 'py_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// MARK_T
 
static PyMethodDef Sq3ValueC_Methods[] = {
 
  // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
  // doc-key: Sq3ValueC,Sq3Value,sc_
  { "GetNull"       , (PyCFunction) NS(Sq3ValueC_GetNull)       , METH_NOARGS|METH_CLASS , GetNull_doc },
  { "HandleResolve" , (PyCFunction) NS(Sq3ValueC_HandleResolve) , METH_O|METH_CLASS      , HandleResolve_doc },
  { "Instances"     , (PyCFunction) NS(Sq3ValueC_Instances)     , METH_NOARGS|METH_CLASS , Instances_doc },
 
  // END-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
  // BEGIN-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
  // doc-key: Sq3ValueC,Sq3Value,oCx
  { "Dup"           , (PyCFunction) NS(Sq3ValueC_Dup)           , METH_NOARGS            , Dup_doc },
 
  // doc-key: Sq3ValueC,Sq3Value,oc_
  { "BUF"           , (PyCFunction) NS(Sq3ValueC_BUF)           , METH_NOARGS            , BUF_doc },
  { "Blob"          , (PyCFunction) NS(Sq3ValueC_Blob)          , METH_NOARGS            , Blob_doc },
  { "Next"          , (PyCFunction) NS(Sq3ValueC_Next)          , METH_NOARGS            , Next_doc },
  { "Prev"          , (PyCFunction) NS(Sq3ValueC_Prev)          , METH_NOARGS            , Prev_doc },
 
  // doc-key: Sq3ValueC,Sq3Value,oco
  { "VtabInFirst"   , (PyCFunction) NS(Sq3ValueC_VtabInFirst)   , METH_NOARGS            , VtabInFirst_doc },
  { "VtabInNext"    , (PyCFunction) NS(Sq3ValueC_VtabInNext)    , METH_NOARGS            , VtabInNext_doc },
 
  // doc-key: Sq3ValueC,Sq3Value,om_
  { "BinaryR"       , (PyCFunction) NS(Sq3ValueC_BinaryR)       , METH_NOARGS            , BinaryR_doc },
  { "Bytes"         , (PyCFunction) NS(Sq3ValueC_Bytes)         , METH_NOARGS            , Bytes_doc },
  { "Double"        , (PyCFunction) NS(Sq3ValueC_Double)        , METH_NOARGS            , Double_doc },
  { "Encoding"      , (PyCFunction) NS(Sq3ValueC_Encoding)      , METH_NOARGS            , Encoding_doc },
  { "FromBind"      , (PyCFunction) NS(Sq3ValueC_FromBind)      , METH_NOARGS            , FromBind_doc },
  // skip class-overload: Sq3ValueHandleGet → HandleGet, NS(Sq3ValueC_HandleGet)
  { "Int"           , (PyCFunction) NS(Sq3ValueC_Int)           , METH_NOARGS            , Int_doc },
  { "Int64"         , (PyCFunction) NS(Sq3ValueC_Int64)         , METH_NOARGS            , Int64_doc },
  // skip class-overload: Sq3ValueLog → Log, NS(Sq3ValueC_Log)
  { "NoChange"      , (PyCFunction) NS(Sq3ValueC_NoChange)      , METH_NOARGS            , NoChange_doc },
  { "NumericType"   , (PyCFunction) NS(Sq3ValueC_NumericType)   , METH_NOARGS            , NumericType_doc },
  { "StringR"       , (PyCFunction) NS(Sq3ValueC_StringR)       , METH_NOARGS            , StringR_doc },
  { "SubType"       , (PyCFunction) NS(Sq3ValueC_SubType)       , METH_NOARGS            , SubType_doc },
  { "Text"          , (PyCFunction) NS(Sq3ValueC_Text)          , METH_NOARGS            , Text_doc },
  { "Type"          , (PyCFunction) NS(Sq3ValueC_Type)          , METH_NOARGS            , Type_doc },
 
  // END-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
    {NULL, NULL, 0, NULL}        /* Sentinel */
};
 
 
OT_CLASS_TYPE_REF NS(Sq3ValueCR) = {
  PyVarObject_HEAD_INIT(NULL, 0)
  .tp_name        = "pymsgque.Sq3ValueC",
  .tp_doc         = "PyMsgque Sq3ValueC Type",
  .tp_basicsize   = sizeof(Sq3ValueC_Obj),
  .tp_itemsize    = 0,
//  .tp_new         = (newfunc)     NS(Sq3ValueC_new),
  .tp_flags       = Py_TPFLAGS_DEFAULT,
  .tp_methods     = Sq3ValueC_Methods,
  .tp_base        = NULL
};
 
int NS(pSq3ValueC_Init) ( MK_RT_ARGS PyObject* m)
{
  ClassInit
 
  return 0;
error:
  return -1;
}
 
// vim: nowrap