Example #1
0
static void clearRegion(gPainter &painter, eWindowStyle &style, eListboxStyle *local_style, ePyObject pforeColor, ePyObject pforeColorSelected, ePyObject pbackColor, ePyObject pbackColorSelected, int selected, gRegion &rc, eRect &sel_clip, const ePoint &offset, bool cursorValid, bool clear=true)
{
	if (selected && sel_clip.valid())
	{
		gRegion part = rc - sel_clip;
		if (!part.empty())
		{
			painter.clip(part);
			style.setStyle(painter, eWindowStyle::styleListboxNormal);
			clearRegionHelper(painter, local_style, offset, pbackColor, cursorValid, clear);
			painter.clippop();
			selected = 0;
		}
		part = rc & sel_clip;
		if (!part.empty())
		{
			painter.clip(part);
			style.setStyle(painter, eWindowStyle::styleListboxSelected);
			clearRegionSelectedHelper(painter, local_style, offset, pbackColorSelected, cursorValid, clear);
			painter.clippop();
			selected = 1;
		}
	}
	else if (selected)
	{
		style.setStyle(painter, eWindowStyle::styleListboxSelected);
		clearRegionSelectedHelper(painter, local_style, offset, pbackColorSelected, cursorValid, clear);
		if (local_style && local_style->m_selection)
			painter.blit(local_style->m_selection, offset, eRect(), gPainter::BT_ALPHATEST);
	}
	else
	{
		style.setStyle(painter, eWindowStyle::styleListboxNormal);
		clearRegionHelper(painter, local_style, offset, pbackColor, cursorValid, clear);
	}

	if (selected)
	{
		if (pforeColorSelected)
		{
			unsigned int color = PyInt_AsUnsignedLongMask(pforeColorSelected);
			painter.setForegroundColor(gRGB(color));
		}
		/* if we have a local foreground color set, use that. */
		else if (local_style && local_style->m_foreground_color_selected_set)
			painter.setForegroundColor(local_style->m_foreground_color_selected);
	}
	else
	{
		if (pforeColor)
		{
			unsigned int color = PyInt_AsUnsignedLongMask(pforeColor);
			painter.setForegroundColor(gRGB(color));
		}
		/* if we have a local foreground color set, use that. */
		else if (local_style && local_style->m_foreground_color_set)
			painter.setForegroundColor(local_style->m_foreground_color);
	}
}
/* This function not only tests the 'k' getargs code, but also the
   PyInt_AsUnsignedLongMask() and PyInt_AsUnsignedLongMask() functions. */
static PyObject *
test_k_code(PyObject *self)
{
	PyObject *tuple, *num;
	unsigned long value;

        tuple = PyTuple_New(1);
        if (tuple == NULL)
        	return NULL;

	/* a number larger than ULONG_MAX even on 64-bit platforms */
        num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
        if (num == NULL)
        	return NULL;

	value = PyInt_AsUnsignedLongMask(num);
	if (value != ULONG_MAX)
        	return raiseTestError("test_k_code",
	    "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");

        PyTuple_SET_ITEM(tuple, 0, num);

        value = 0;
        if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
        	return NULL;
        if (value != ULONG_MAX)
        	return raiseTestError("test_k_code",
			"k code returned wrong value for long 0xFFF...FFF");

	Py_DECREF(num);
        num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);
        if (num == NULL)
        	return NULL;

	value = PyInt_AsUnsignedLongMask(num);
	if (value != (unsigned long)-0x42)
        	return raiseTestError("test_k_code",
	    "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");

        PyTuple_SET_ITEM(tuple, 0, num);

	value = 0;
        if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
        	return NULL;
        if (value != (unsigned long)-0x42)
        	return raiseTestError("test_k_code",
			"k code returned wrong value for long -0xFFF..000042");

	Py_DECREF(tuple);
	Py_INCREF(Py_None);
	return Py_None;
}
Example #3
0
static PyObject *
win32_SetNamedPipeHandleState(PyObject *self, PyObject *args)
{
    HANDLE hNamedPipe;
    PyObject *oArgs[3];
    DWORD dwArgs[3], *pArgs[3] = {NULL, NULL, NULL};
    int i;

    if (!PyArg_ParseTuple(args, F_HANDLE "OOO",
                          &hNamedPipe, &oArgs[0], &oArgs[1], &oArgs[2]))
        return NULL;

    PyErr_Clear();

    for (i = 0 ; i < 3 ; i++) {
        if (oArgs[i] != Py_None) {
            dwArgs[i] = PyInt_AsUnsignedLongMask(oArgs[i]);
            if (PyErr_Occurred())
                return NULL;
            pArgs[i] = &dwArgs[i];
        }
    }

    if (!SetNamedPipeHandleState(hNamedPipe, pArgs[0], pArgs[1], pArgs[2]))
        return PyErr_SetFromWindowsErr(0);

    Py_RETURN_NONE;
}
Example #4
0
// @object PROPSPEC|Identifies a property.  Can be either an int property id, or a str/unicode property name.
BOOL PyWinObject_AsPROPSPECs( PyObject *ob, PROPSPEC **ppRet, ULONG *pcRet)
{
	TmpPyObject tuple=PyWinSequence_Tuple(ob, pcRet);
	if (tuple==NULL)
		return FALSE;
	size_t numBytes = sizeof(PROPSPEC) * *pcRet;
	*ppRet = (PROPSPEC *)malloc(numBytes);
	if (*ppRet==NULL) {
		PyErr_NoMemory();
		return FALSE;
	}
	ZeroMemory(*ppRet, numBytes);
	for (DWORD i=0; i<*pcRet; i++) {
		PyObject *sub = PyTuple_GET_ITEM((PyObject *)tuple, i);
		(*ppRet)[i].propid = PyInt_AsUnsignedLongMask(sub);
		if ((*ppRet)[i].propid != (ULONG)-1 || !PyErr_Occurred())
			(*ppRet)[i].ulKind = PRSPEC_PROPID;
		else{
			PyErr_Clear();
			(*ppRet)[i].lpwstr = NULL;
			if (PyWinObject_AsWCHAR(sub, &(*ppRet)[i].lpwstr))
				(*ppRet)[i].ulKind = PRSPEC_LPWSTR;
			else{
				PyErr_Clear();
				PyErr_SetString(PyExc_TypeError, "PROPSPECs must be a sequence of strings or integers");
				PyObject_FreePROPSPECs(*ppRet, *pcRet);
				*ppRet=NULL;
				return FALSE;
				}
			}
		}
	return TRUE;
}
Example #5
0
static PyObject* Cache_iterload(Cache* self, PyObject *args, PyObject *kwds)
{
    PyObject *addrs;
    unsigned int length = 1;
    
    static char *kwlist[] = {"addrs", "length", NULL};
    PyArg_ParseTupleAndKeywords(args, kwds, "O|I", kwlist, &addrs, &length);
    
    // Get and check iterator
    PyObject *addrs_iter = PyObject_GetIter(addrs);
    if(addrs_iter == NULL) {
        PyErr_SetString(PyExc_ValueError, "addrs is not iteratable");
        return NULL;
    }

    // Iterate of elements in addrs
    PyObject *addr;
    while((addr = PyIter_Next(addrs_iter))) {
        // Each address is expanded to a certain length (default is 1)
        for(int i=0; i<length; i++) {
#if PY_MAJOR_VERSION >= 3
            Cache__load(self, PyLong_AsUnsignedLongMask(addr)+i);
#else
            Cache__load(self, PyInt_AsUnsignedLongMask(addr)+i);
#endif
        }
        Py_DECREF(addr);
    }
    Py_DECREF(addrs_iter);
    Py_RETURN_NONE;
}
Example #6
0
static void clearRegionHelper(gPainter &painter, eListboxStyle *local_style, const ePoint &offset, ePyObject &pbackColor, bool cursorValid, bool clear=true)
{
	if (pbackColor)
	{
		unsigned int color = PyInt_AsUnsignedLongMask(pbackColor);
		painter.setBackgroundColor(gRGB(color));
	}
	else if (local_style)
	{
		if (local_style && local_style->m_background_color_set)
			painter.setBackgroundColor(local_style->m_background_color);
		if (local_style->m_background && cursorValid)
		{
			if (local_style->m_transparent_background)
				painter.blit(local_style->m_background, offset, eRect(), gPainter::BT_ALPHATEST);
			else
				painter.blit(local_style->m_background, offset, eRect(), 0);
			return;
		}
		else if (local_style->m_transparent_background)
			return;
	}
	if (clear)
		painter.clear();
}
Example #7
0
static void pybackend_ip_choose(u_int32_t *addr)
{
    PyObject *ret = NULL;
    PyObject *arg0 = NULL;

    dbglog("pybackend plugin: ip_choose_hook(addr = %d)", *addr);

    arg0 = PyInt_FromSize_t(*addr);
    ret = pybackend_call_function("ip_choose_hook", 1, arg0);
    if (ret == NULL || ret == Py_None)
    {
        goto Exit;
    }

    if (!PyInt_Check(ret))
    {
        warn("pybackend plugin: return value of ip_choose_hook() is not an int");
        goto Exit;
    }

    //
    // No failure.
    //

    *addr = PyInt_AsUnsignedLongMask(ret);

Exit:

    Py_CLEAR(arg0);
    Py_CLEAR(ret);

    dbglog("pybackend plugin: ip_choose_hook: %d", *addr);
    return;
}
Example #8
0
static PyObject *
P_set(void *ptr, PyObject *value, Py_ssize_t size)
{
    void *v;
    if (value == Py_None) {
        *(void **)ptr = NULL;
        _RET(value);
    }

    if (!PyInt_Check(value) && !PyLong_Check(value)) {
        PyErr_SetString(PyExc_TypeError,
                        "cannot be converted to pointer");
        return NULL;
    }

#if SIZEOF_VOID_P <= SIZEOF_LONG
    v = (void *)PyInt_AsUnsignedLongMask(value);
#else
#ifndef HAVE_LONG_LONG
#   error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long"
#elif SIZEOF_LONG_LONG < SIZEOF_VOID_P
#   error "PyLong_AsVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)"
#endif
    v = (void *)PyInt_AsUnsignedLongLongMask(value);
#endif

    if (PyErr_Occurred())
        return NULL;

    *(void **)ptr = v;
    _RET(value);
}
Example #9
0
static PyObject *
do_close_file (PyObject *self, PyObject *args, PyObject *kwds)
{
    PyObject       *cobj;
    PyObject       *iobj;
    NsLibrary      *lib;
    ns_RESULT       res;
    uint32          file_id;

    if (!PyArg_ParseTuple (args, "OO", &cobj, &iobj))
    {
        PyErr_SetString (PyExc_StandardError, "Could not parse arguments");
        return NULL;
    }

    if (!PyCObject_Check (cobj) || !PyInt_Check (iobj))
    {
        PyErr_SetString (PyExc_TypeError, "Wrong argument type(s)");
        return NULL;
    }

    lib = PyCObject_AsVoidPtr (cobj);
    file_id = (uint32) PyInt_AsUnsignedLongMask (iobj);

    res = lib->CloseFile (file_id);

    if (check_result_is_error (res, lib))
        return NULL;

    Py_RETURN_NONE;
}
Example #10
0
static PyObject *
z_set(void *ptr, PyObject *value, Py_ssize_t size)
{
    if (value == Py_None) {
        *(char **)ptr = NULL;
        Py_INCREF(value);
        return value;
    }
    if (PyString_Check(value)) {
        *(char **)ptr = PyString_AS_STRING(value);
        Py_INCREF(value);
        return value;
    } else if (PyUnicode_Check(value)) {
        PyObject *str = PyUnicode_AsEncodedString(value,
                                                  _ctypes_conversion_encoding,
                                                  _ctypes_conversion_errors);
        if (str == NULL)
            return NULL;
        *(char **)ptr = PyString_AS_STRING(str);
        return str;
    } else if (PyInt_Check(value) || PyLong_Check(value)) {
#if SIZEOF_VOID_P == SIZEOF_LONG_LONG
        *(char **)ptr = (char *)PyInt_AsUnsignedLongLongMask(value);
#else
        *(char **)ptr = (char *)PyInt_AsUnsignedLongMask(value);
#endif
        _RET(value);
    }
    PyErr_Format(PyExc_TypeError,
                 "string or integer address expected instead of %s instance",
                 value->ob_type->tp_name);
    return NULL;
}
void PythonScriptController_pyObjectToValue(PyObject* pyObject, unsigned int & val)
{
    if (pyObject && pyObject!=Py_None && PyInt_Check(pyObject))
        val = (unsigned int)PyInt_AsUnsignedLongMask(pyObject);
    else
        SP_MESSAGE_ERROR("Cannot convert pyObject to unsigned int");
}
Example #12
0
static PyObject *
do_get_index_by_time(PyObject *self, PyObject *args, PyObject *kwds)
{
    NsLibrary  *lib;
    PyObject   *cobj;
    PyObject   *iobj, *id_obj, *tp_obj, *fl_obj;
    double      timepoint;
    uint32      file_id;
    uint32      entity_id;
    uint32      index;
    uint32      flags;
    ns_RESULT   res;


    if (!PyArg_ParseTuple (args, "OOOOO", &cobj, &iobj, &id_obj, &tp_obj, &fl_obj))
    {
        PyErr_SetString (PyExc_StandardError, "Could not parse arguments");
        return NULL;
    }

    if (!PyCObject_Check (cobj) || !PyInt_Check (iobj) ||
            !PyInt_Check (id_obj) || !PyFloat_Check (tp_obj) ||
            !PyInt_Check (fl_obj))
    {
        PyErr_SetString (PyExc_TypeError, "Wrong argument type(s)");
        return NULL;
    }

    lib = PyCObject_AsVoidPtr (cobj);
    file_id = (uint32) PyInt_AsUnsignedLongMask (iobj);
    entity_id = (uint32) PyInt_AsUnsignedLongMask (id_obj);
    timepoint = PyFloat_AsDouble (tp_obj);
    flags = (uint32) PyInt_AsUnsignedLongMask (fl_obj);

    res = lib->GetIndexByTime (file_id,
                               entity_id,
                               timepoint,
                               flags,
                               &index);

    if (check_result_is_error (res, lib))
        return NULL;

    return PyInt_FromLong (index);
}
 void _extract(PyObject *obj, unsigned long &val)
 {
     if (PyInt_Check(obj))
         val = (unsigned long)PyInt_AsUnsignedLongMask(obj);
     else if (PyFloat_Check(obj))
         val = (unsigned long)PyFloat_AsDouble(obj);
     else
         val = PyLong_AsUnsignedLong(obj);
 }
Example #14
0
static PyObject *
fs_dir_iterate (Filesystem *self,
                PyObject   *args,
                PyObject   *kwargs)
{
  errcode_t  ret;
  WalkData   wdata;
  PyObject  *py_func, *py_data = NULL, *py_dir = NULL;
  uint64_t   dir;
  int        flags = OCFS2_DIRENT_FLAG_EXCLUDE_DOTS;

  static char *kwlist[] = { "callback", "data", "dir", "flags", NULL };

  if (!PyArg_ParseTupleAndKeywords (args, kwargs,
				    "O|OOi:dir_iterate", kwlist,
				    &py_func, &py_data, &py_dir, &flags))
    return NULL;

  if (!PyCallable_Check (py_func))
    {
      PyErr_SetString (PyExc_TypeError, "callback must be a callable object");
      return NULL;
    }

  if (py_dir == NULL || py_dir == Py_None)
    dir = self->fs->fs_root_blkno;
  else if (DirEntry_Check (py_dir))
    dir = ((DirEntry *) py_dir)->dentry.inode;
  else if (PyInt_Check (py_dir))
    dir = PyInt_AsUnsignedLongMask (py_dir);
  else if (PyLong_Check (py_dir))
    dir = PyLong_AsUnsignedLongLongMask (py_dir);
  else
    {
      PyErr_SetString (PyExc_TypeError, "dir must be DirEntry or integer");
      return NULL;
    }

  Py_INCREF (py_func);
  wdata.func = py_func;

  Py_XINCREF (py_data);
  wdata.data = py_data;

  wdata.fs = self;

  /* XXX: handle errors */
  ret = ocfs2_dir_iterate (self->fs, dir, flags, NULL, walk_dirs, &wdata);

  Py_DECREF (py_func);
  Py_XDECREF (py_data);

  Py_INCREF (Py_None);
  return Py_None;
}
Example #15
0
static int hdrAppendItem(Header h, rpmTagVal tag, rpmTagType type, PyObject *item)
{
    int rc = 0;

    switch (type) {
    case RPM_I18NSTRING_TYPE: /* XXX this needs to be handled separately */
    case RPM_STRING_TYPE:
    case RPM_STRING_ARRAY_TYPE: {
	PyObject *str = NULL;
	if (utf8FromPyObject(item, &str)) 
	    rc = headerPutString(h, tag, PyBytes_AsString(str));
	Py_XDECREF(str);
	} break;
    case RPM_BIN_TYPE: {
	uint8_t *val = (uint8_t *) PyBytes_AsString(item);
	rpm_count_t len = PyBytes_Size(item);
	rc = headerPutBin(h, tag, val, len);
	} break;
    case RPM_INT64_TYPE: {
	uint64_t val = PyInt_AsUnsignedLongLongMask(item);
	rc = headerPutUint64(h, tag, &val, 1);
	} break;
    case RPM_INT32_TYPE: {
	uint32_t val = PyInt_AsUnsignedLongMask(item);
	rc = headerPutUint32(h, tag, &val, 1);
	} break;
    case RPM_INT16_TYPE: {
	uint16_t val = PyInt_AsUnsignedLongMask(item);
	rc = headerPutUint16(h, tag, &val, 1);
	} break;
    case RPM_INT8_TYPE:
    case RPM_CHAR_TYPE: {
	uint8_t val = PyInt_AsUnsignedLongMask(item);
	rc = headerPutUint8(h, tag, &val, 1);
	} break;
    default:
	PyErr_SetString(PyExc_TypeError, "unhandled datatype");
    }
    return rc;
}
Example #16
0
static PyObject *
do_get_time_by_index (PyObject *self, PyObject *args, PyObject *kwds)
{
    NsLibrary      *lib;
    PyObject       *cobj;
    PyObject       *iobj, *id_obj, *idx_obj;
    uint32          file_id;
    uint32          entity_id;
    uint32          index;
    double          timepoint;
    ns_RESULT       res;

    if (!PyArg_ParseTuple (args, "OOOO", &cobj, &iobj, &id_obj, &idx_obj))
    {
        PyErr_SetString (PyExc_StandardError, "Could not parse arguments");
        return NULL;
    }

    if (!PyCObject_Check (cobj) || !PyInt_Check (iobj) ||
            !PyInt_Check (id_obj) || !PyInt_Check (idx_obj))
    {
        PyErr_SetString (PyExc_TypeError, "Wrong argument type(s)");
        return NULL;
    }

    lib = PyCObject_AsVoidPtr (cobj);
    file_id = (uint32) PyInt_AsUnsignedLongMask (iobj);
    entity_id = (uint32) PyInt_AsUnsignedLongMask (id_obj);
    index = (uint32) PyInt_AsUnsignedLongMask (idx_obj);

    res = lib->GetTimeByIndex (file_id,
                               entity_id,
                               index,
                               &timepoint);

    if (check_result_is_error (res, lib))
        return NULL;

    return Py_BuildValue ("d", timepoint);
}
Example #17
0
PyObject* graph_colorize(PyObject* self, PyObject* pyobject) {
   INIT_SELF_GRAPH();
   unsigned int ncolors = PyInt_AsUnsignedLongMask(pyobject);
   try {
      so->_graph->colorize(ncolors);
      RETURN_VOID();
   }
   catch (std::runtime_error e) {
      PyErr_SetString(PyExc_RuntimeError, e.what());
      return NULL;
   }
   
}
Example #18
0
static PyObject *
ETContext_open(ETContextObject* self, PyObject *args)
{
    DWORD dwRet;
    ET_OPENINFO OpenInfo;
    PyObject *pyOpenInfo=NULL;
    if (!PyArg_ParseTuple(args, "|O", &pyOpenInfo)) {
      return NULL;
    }
    Py_XINCREF(pyOpenInfo);
  #if defined(WIN32)
    if(NULL != pyOpenInfo){
      //printf("PyTuple_Check(pyOpenInfo)=%d\n",PyTuple_Check(pyOpenInfo));
      //printf("PyTuple_Size(pyOpenInfo)=%d\n",PyTuple_Size(pyOpenInfo));
      //printf("PyInt_Check(PyTuple_GetItem(pyOpenInfo,0)=%d\n",PyInt_Check(PyTuple_GetItem(pyOpenInfo,0)));
      //printf("PyInt_Check(PyTuple_GetItem(pyOpenInfo,1))=%d\n",PyInt_Check(PyTuple_GetItem(pyOpenInfo,1)));
      if(!PyTuple_Check(pyOpenInfo) 
        || 2!=PyTuple_Size(pyOpenInfo)
        || !PyInt_Check(PyTuple_GetItem(pyOpenInfo,0))
        || !PyInt_Check(PyTuple_GetItem(pyOpenInfo,1))){
        INVALID_PARAMS("Open Info must be a tuple with 2 integers.",NULL);
      }
      OpenInfo.dwOpenInfoSize=PyInt_AsUnsignedLongMask(PyTuple_GetItem(pyOpenInfo,0));
      OpenInfo.dwShareMode=PyInt_AsUnsignedLongMask(PyTuple_GetItem(pyOpenInfo,1));
      //printf("OpenInfo: %08x,%08x\n",OpenInfo.dwOpenInfoSize,OpenInfo.dwShareMode);
      dwRet= ETOpenEx(&self->context,&OpenInfo);
    }else{
      dwRet = ETOpen(&self->context);
    }
  #else
      dwRet = ETOpen(&self->context);
  #endif /*WIN32 | LINUX*/
    Py_XDECREF(pyOpenInfo);
    DWRET_VALIDATE(dwRet,NULL);
    Py_XINCREF(self);
    return self;
}
Example #19
0
static int
get_ulong(PyObject *v, unsigned long *p)
{
    unsigned long x;
    if (PyFloat_Check(v)) {
        PyErr_SetString(PyExc_TypeError,
                        "int expected instead of float");
        return -1;
    }
    x = PyInt_AsUnsignedLongMask(v);
    if (x == (unsigned long)-1 && PyErr_Occurred())
        return -1;
    *p = x;
    return 0;
}
Example #20
0
static inline int seq2array(const PyObject *seq, u8 *arr) {
	u8 i, j;
	PyObject *item;

	for(i = 0; i < 10; i++) {
		arr[i] = 0;
		for (j = 0; j < 8; j++) {
			item = PySequence_Fast_GET_ITEM(seq, 8 * i + j);
			if(!item)
				return 1;

			arr[i] |= (((u8)PyInt_AsUnsignedLongMask(item)) << j);
		}
	}

	return 0;
}	
Example #21
0
bool py_to_color(PyObject *o, SproxelColor &c)
{
  if (PyInt_Check(o) || PyLong_Check(o))
  {
    unsigned i=PyInt_AsUnsignedLongMask(o);
    if (PyErr_Occurred())
    {
      PyErr_Clear();
      i=PyLong_AsUnsignedLongMask(o);
      if (PyErr_Occurred()) return false;
    }
    if ((i&0xFF000000)==0 && i!=0) i|=0xFF000000;
    c.a=((i>>24)&0xFF)/255.0f;
    c.r=((i>>16)&0xFF)/255.0f;
    c.g=((i>> 8)&0xFF)/255.0f;
    c.b=((i    )&0xFF)/255.0f;
    return true;
  }
Example #22
0
QUISK_EXPORT long QuiskGetConfigLong(const char * name, long deflt)
{  // return deflt for failure.  Accept int or float.
  long res;
  PyObject * attr;  
  if (!quisk_pyConfig || PyErr_Occurred()) {
    return deflt;
  }
  attr = PyObject_GetAttrString(quisk_pyConfig, name);
  if (attr) {
    res = PyInt_AsUnsignedLongMask(attr);  // This works for floats too!
    Py_DECREF(attr);
    return res;		// success
  }
  else {
    PyErr_Clear();
  }
  return deflt;		// failure
}
Example #23
0
static PyObject *
ETContext_create_dir(ETContextObject* self, PyObject *args)
{
  BYTE pszDirId[5]={0};
  WORD dirId=0;
  DWORD dwRet,dwDirSize,dwFlags=ET_CREATE_ROOT_DIR;
  ET_CREATEDIRINFO createInfo={0};
  PyObject *pyDirInfo=NULL,*pyAtr=NULL;
  if(!PyArg_ParseTuple(args, "HII|O", &dirId,&dwDirSize,&dwFlags,&pyDirInfo)) {
    return NULL;
  }
  Py_XINCREF(pyDirInfo);

  if(0!=dirId){
    sprintf(pszDirId,"%04x",dirId);
  }else{
    dwDirSize=0;
    dwFlags=ET_CREATE_ROOT_DIR;
  }
  if(NULL != pyDirInfo){
    if(!PyTuple_Check(pyDirInfo) 
        || 2!=PyTuple_Size(pyDirInfo)
        || !PyInt_Check(PyTuple_GetItem(pyDirInfo,0))
        || !PyString_Check(PyTuple_GetItem(pyDirInfo,1))){
      INVALID_PARAMS("DirInfo should be a tuple with one integer and one bytearray!",NULL);
    }
    pyAtr = PyTuple_GetItem(pyDirInfo,1);
    Py_XINCREF(pyAtr);
    dwRet = PyString_Size(pyAtr);
    if(dwRet>16 || dwRet<1){
      INVALID_PARAMS("ATR length must between 1~16!",NULL);
    }
    createInfo.dwCreateDirInfoSize = PyInt_AsUnsignedLongMask(PyTuple_GetItem(pyDirInfo,0));
    memcpy(createInfo.szAtr,PyString_AsString(pyAtr),dwRet);
    dwRet = ETCreateDirEx(&self->context,pszDirId,dwDirSize,dwFlags,&createInfo);
    DWRET_VALIDATE(dwRet,NULL);
  }else{
    dwRet = ETCreateDir(&self->context,pszDirId,dwDirSize,dwFlags);
    DWRET_VALIDATE(dwRet,NULL);
  }
  Py_XDECREF(pyAtr);
  Py_XDECREF(pyDirInfo);
  Py_RETURN_TRUE;
}
Example #24
0
// Alocates and populates an array of DWORDS from a sequence of Python ints
BOOL PyWinObject_AsDWORDArray(PyObject *obdwords, DWORD **pdwords, DWORD *item_cnt, BOOL bNoneOk)
{
	BOOL ret=TRUE;
	DWORD bufsize, tuple_index;
	PyObject *dwords_tuple=NULL, *tuple_item;
	*pdwords=NULL;
	*item_cnt=0;
	if (obdwords==Py_None){
		if (bNoneOk)
			return TRUE;
		PyErr_SetString(PyExc_ValueError,"Sequence of dwords cannot be None");
		return FALSE;
		}
	if ((dwords_tuple=PyWinSequence_Tuple(obdwords, item_cnt))==NULL)
		return FALSE;	// last exit without cleaning up
	bufsize=*item_cnt * sizeof(DWORD);
	*pdwords=(DWORD *)malloc(bufsize);
	if (*pdwords==NULL){
		PyErr_Format(PyExc_MemoryError, "Unable to allocate %d bytes", bufsize);
		ret=FALSE;
		}
	else
		for (tuple_index=0; tuple_index<*item_cnt; tuple_index++){
			tuple_item=PyTuple_GET_ITEM(dwords_tuple,tuple_index);
			// Doesn't check for overflow, but will accept a python long
			//  greater than INT_MAX (even on python 2.3).  Also accepts
			//  negatives and converts to the correct hex representation
			(*pdwords)[tuple_index]=PyInt_AsUnsignedLongMask(tuple_item);
			if (((*pdwords)[tuple_index]==-1) && PyErr_Occurred()){
				ret=FALSE;
				break;
				}
			}
	if (!ret)
		if (*pdwords!=NULL){
			free(*pdwords);
			*pdwords=NULL;
			*item_cnt=0;
			}
	Py_XDECREF(dwords_tuple);
	return ret;
}
Example #25
0
static ePyObject lookupColor(ePyObject color, ePyObject data)
{
	if (color == Py_None)
		return ePyObject();

	if ((!color) && (!data))
		return color;

	unsigned int icolor = PyInt_AsUnsignedLongMask(color);

		/* check if we have the "magic" template color */
	if ((icolor & 0xFF000000) == 0xFF000000)
	{
		int index = icolor & 0xFFFFFF;
		eDebug("[eListboxPythonMultiContent] template color index: %d", index);
		return PyTuple_GetItem(data, index);
	}

	if (color == Py_None)
		return ePyObject();

	return color;
}
Example #26
0
static ePyObject lookupColor(ePyObject color, ePyObject data)
{
	if (color == Py_None)
		return ePyObject();

	if ((!color) && (!data))
		return color;

	unsigned int icolor = PyInt_AsUnsignedLongMask(color);

		/* check if we have the "magic" template color */
	if (data && (icolor & 0xFF000000) == 0xFF000000)
	{
		int index = icolor & 0xFFFFFF;
		if (PyTuple_GetItem(data, index) == Py_None)
			return ePyObject();
		return PyTuple_GetItem(data, index);
	}

	if (color == Py_None)
		return ePyObject();

	return color;
}
Example #27
0
static void __pyx_f_13cunsignedlong_f(void) {
  unsigned long __pyx_v_x;
  PyObject *__pyx_v_y;
  unsigned long __pyx_1;
  PyObject *__pyx_2 = 0;
  __pyx_v_y = Py_None; Py_INCREF(Py_None);

  /* "/Local/Projects/D/Pyrex/Source/Tests/8/cunsignedlong.pyx":4 */
  __pyx_1 = PyInt_AsUnsignedLongMask(__pyx_v_y); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; goto __pyx_L1;}
  __pyx_v_x = __pyx_1;

  /* "/Local/Projects/D/Pyrex/Source/Tests/8/cunsignedlong.pyx":5 */
  __pyx_2 = PyLong_FromUnsignedLong(__pyx_v_x); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; goto __pyx_L1;}
  Py_DECREF(__pyx_v_y);
  __pyx_v_y = __pyx_2;
  __pyx_2 = 0;

  goto __pyx_L0;
  __pyx_L1:;
  Py_XDECREF(__pyx_2);
  __Pyx_WriteUnraisable("cunsignedlong.f");
  __pyx_L0:;
  Py_DECREF(__pyx_v_y);
}
Example #28
0
int
get_python_uint_value(PyObject* dv, unsigned int* pint)
{
    int cc = 1;
    if (PyInt_Check(dv) || PyLong_Check(dv)) {
        unsigned long v = PyInt_AsUnsignedLongMask(dv);
        *pint = (unsigned int)v;
    }
    else if (PyString_Check(dv)) {
        /* Convert from string to int */
        unsigned long tid;
        char *endptr;
        char* p = PyString_AsString(dv);
        tid = strtoul(p, &endptr, 10);
        if(endptr == p || *endptr)
            cc = -1;    /* Invalid numeric format */
        else
            *pint = (unsigned int)tid;
    }
    else {
        cc = -1;    /* Don't know how to convert this */
    }
    return cc;
}
Example #29
0
static PyObject *
fs_dir_scan (Filesystem *self,
             PyObject   *args,
             PyObject   *kwargs)
{
  errcode_t       ret;
  PyObject       *py_dir = NULL;
  uint64_t        dir;
  int             flags = OCFS2_DIR_SCAN_FLAG_EXCLUDE_DOTS;
  ocfs2_dir_scan *scan;

  static char *kwlist[] = { "dir", "flags", NULL };

  if (!PyArg_ParseTupleAndKeywords (args, kwargs,
				    "|Oi:dir_scan", kwlist,
				    &py_dir, &flags))
    return NULL;

  if (py_dir == NULL || py_dir == Py_None)
    dir = self->fs->fs_root_blkno;
  else if (DirEntry_Check (py_dir))
    dir = ((DirEntry *) py_dir)->dentry.inode;
  else if (PyInt_Check (py_dir))
    dir = PyInt_AsUnsignedLongMask (py_dir);
  else if (PyLong_Check (py_dir))
    dir = PyLong_AsUnsignedLongLongMask (py_dir);
  else
    {
      PyErr_SetString (PyExc_TypeError, "dir must be DirEntry or integer");
      return NULL;
    }

  CHECK_ERROR (ocfs2_open_dir_scan (self->fs, dir, flags, &scan));

  return dir_scan_iter_new (self, scan);
}
Example #30
0
static char *
convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf,
	      size_t bufsize, PyObject **freelist)
{
	char *format = *p_format;
	char c = *format++;
	
	switch (c) {
	
	case 'b': { /* unsigned byte -- very short int */
		char *p = va_arg(*p_va, char *);
		long ival;
		if (float_argument_error(arg))
			return NULL;
		ival = PyInt_AsLong(arg);
		if (ival == -1 && PyErr_Occurred())
			return converterr("integer<b>", arg, msgbuf, bufsize);
		else if (ival < 0) {
			PyErr_SetString(PyExc_OverflowError,
			"unsigned byte integer is less than minimum");
			return converterr("integer<b>", arg, msgbuf, bufsize);
		}
		else if (ival > UCHAR_MAX) {
			PyErr_SetString(PyExc_OverflowError,
			"unsigned byte integer is greater than maximum");
			return converterr("integer<b>", arg, msgbuf, bufsize);
		}
		else
			*p = (unsigned char) ival;
		break;
	}
	
	case 'B': {/* byte sized bitfield - both signed and unsigned
		      values allowed */  
		char *p = va_arg(*p_va, char *);
		long ival;
		if (float_argument_error(arg))
			return NULL;
		ival = PyInt_AsUnsignedLongMask(arg);
		if (ival == -1 && PyErr_Occurred())
			return converterr("integer<B>", arg, msgbuf, bufsize);
		else
			*p = (unsigned char) ival;
		break;
	}
	
	case 'h': {/* signed short int */
		short *p = va_arg(*p_va, short *);
		long ival;
		if (float_argument_error(arg))
			return NULL;
		ival = PyInt_AsLong(arg);
		if (ival == -1 && PyErr_Occurred())
			return converterr("integer<h>", arg, msgbuf, bufsize);
		else if (ival < SHRT_MIN) {
			PyErr_SetString(PyExc_OverflowError,
			"signed short integer is less than minimum");
			return converterr("integer<h>", arg, msgbuf, bufsize);
		}
		else if (ival > SHRT_MAX) {
			PyErr_SetString(PyExc_OverflowError,
			"signed short integer is greater than maximum");
			return converterr("integer<h>", arg, msgbuf, bufsize);
		}
		else
			*p = (short) ival;
		break;
	}
	
	case 'H': { /* short int sized bitfield, both signed and
		       unsigned allowed */ 
		unsigned short *p = va_arg(*p_va, unsigned short *);
		long ival;
		if (float_argument_error(arg))
			return NULL;
		ival = PyInt_AsUnsignedLongMask(arg);
		if (ival == -1 && PyErr_Occurred())
			return converterr("integer<H>", arg, msgbuf, bufsize);
		else
			*p = (unsigned short) ival;
		break;
	}
	
	case 'i': {/* signed int */
		int *p = va_arg(*p_va, int *);
		long ival;
		if (float_argument_error(arg))
			return NULL;
		ival = PyInt_AsLong(arg);
		if (ival == -1 && PyErr_Occurred())
			return converterr("integer<i>", arg, msgbuf, bufsize);
		else if (ival > INT_MAX) {
			PyErr_SetString(PyExc_OverflowError,
				"signed integer is greater than maximum");
			return converterr("integer<i>", arg, msgbuf, bufsize);
		}
		else if (ival < INT_MIN) {
			PyErr_SetString(PyExc_OverflowError,
				"signed integer is less than minimum");
			return converterr("integer<i>", arg, msgbuf, bufsize);
		}
		else
			*p = ival;
		break;
	}

	case 'I': { /* int sized bitfield, both signed and
		       unsigned allowed */ 
		unsigned int *p = va_arg(*p_va, unsigned int *);
		unsigned int ival;
		if (float_argument_error(arg))
			return NULL;
		ival = PyInt_AsUnsignedLongMask(arg);
		if (ival == -1 && PyErr_Occurred())
			return converterr("integer<I>", arg, msgbuf, bufsize);
		else
			*p = ival;
		break;
	}
	
	case 'l': {/* long int */
		long *p = va_arg(*p_va, long *);
		long ival;
		if (float_argument_error(arg))
			return NULL;
		ival = PyInt_AsLong(arg);
		if (ival == -1 && PyErr_Occurred())
			return converterr("integer<l>", arg, msgbuf, bufsize);
		else
			*p = ival;
		break;
	}

	case 'k': { /* long sized bitfield */
		unsigned long *p = va_arg(*p_va, unsigned long *);
		unsigned long ival;
		if (PyInt_Check(arg))
			ival = PyInt_AsUnsignedLongMask(arg);
		else if (PyLong_Check(arg))
			ival = PyLong_AsUnsignedLongMask(arg);
		else
			return converterr("integer<k>", arg, msgbuf, bufsize);
		*p = ival;
		break;
	}
	
	case 'f': {/* float */
		float *p = va_arg(*p_va, float *);
		double dval = PyFloat_AsDouble(arg);
		if (PyErr_Occurred())
			return converterr("float<f>", arg, msgbuf, bufsize);
		else
			*p = (float) dval;
		break;
	}
	
	case 'd': {/* double */
		double *p = va_arg(*p_va, double *);
		double dval = PyFloat_AsDouble(arg);
		if (PyErr_Occurred())
			return converterr("float<d>", arg, msgbuf, bufsize);
		else
			*p = dval;
		break;
	}
	
	case 'c': {/* char */
		char *p = va_arg(*p_va, char *);
		if (PyString_Check(arg) && PyString_Size(arg) == 1)
			*p = PyString_AS_STRING(arg)[0];
		else
			return converterr("char", arg, msgbuf, bufsize);
		break;
	}
	
	case 's': {/* string */
		if (*format == '#') {
			void **p = (void **)va_arg(*p_va, char **);
			int *q = va_arg(*p_va, int *);
			
			if (PyString_Check(arg)) {
				*p = PyString_AS_STRING(arg);
				*q = PyString_GET_SIZE(arg);
			}
			else { /* any buffer-like object */
				char *buf;
				int count = convertbuffer(arg, p, &buf);
				if (count < 0)
					return converterr(buf, arg, msgbuf, bufsize);
				*q = count;
			}
			format++;
		} else {
			char **p = va_arg(*p_va, char **);
			
			if (PyString_Check(arg))
				*p = PyString_AS_STRING(arg);
			else
				return converterr("string", arg, msgbuf, bufsize);
			if ((int)strlen(*p) != PyString_Size(arg))
				return converterr("string without null bytes",
						  arg, msgbuf, bufsize);
		}
		break;
	}