siplib.c

这是关于RFC3261实现sip的源代码

				PyObject *xfer = va_arg(va, PyObject *);

				el = sip_api_convert_from_instance(p, wt, xfer);
			}

			break;

		case 'D':
			{
				void *p = va_arg(va, void *);
				const sipMappedType *mt = va_arg(va, const sipMappedType *);
				PyObject *xfer = va_arg(va, PyObject *);

				el = sip_api_convert_from_mapped_type(p, mt, xfer);
			}

			break;

		case 'M':
		case 'O':
			{
				void *sipCpp = va_arg(va,void *);
				sipWrapperType *wt = va_arg(va,sipWrapperType *);

				el = sip_api_convert_from_instance(sipCpp,wt,NULL);
			}

			break;

		case 'N':
		case 'P':
			{
				void *sipCpp = va_arg(va,void *);
				sipWrapperType *wt = va_arg(va,sipWrapperType *);

				el = sip_api_convert_from_new_instance(sipCpp,wt,NULL);
			}

			break;

		case 'R':
			el = va_arg(va,PyObject *);
			break;

		case 'S':
			el = va_arg(va,PyObject *);
			Py_INCREF(el);
			break;

		case 'T':
			{
				void *sipCpp = va_arg(va,void *);
				sipConvertFromFunc func = va_arg(va,sipConvertFromFunc);

				el = func(sipCpp, NULL);
			}

			break;

		case 'V':
			el = sip_api_convert_from_void_ptr(va_arg(va,void *));
			break;

		default:
			PyErr_Format(PyExc_SystemError,"buildObject(): invalid format character '%c'",ch);
			el = NULL;
		}

		if (el == NULL)
		{
			Py_XDECREF(obj);
			return NULL;
		}

		if (obj == NULL)
			return el;

		PyTuple_SET_ITEM(obj,i,el);
		++i;
	}

	return obj;
}


/*
 * Parse a result object based on a format string.
 */
static int sip_api_parse_result(int *isErr,PyObject *method,PyObject *res,char *fmt,...)
{
	int tupsz, rc = 0;
	va_list va;

	va_start(va,fmt);

	/* Basic validation of the format string. */

	if (*fmt == '(')
	{
		char *ep;

		if ((ep = strchr(fmt,')')) == NULL || ep[1] != '\0')
		{
			PyErr_Format(PyExc_SystemError, "sipParseResult(): invalid format string \"%s\"", fmt);
			rc = -1;
		}
		else
		{
			tupsz = ep - ++fmt;

			if (tupsz >= 0 && (!PyTuple_Check(res) || PyTuple_GET_SIZE(res) != tupsz))
			{
				sip_api_bad_catcher_result(method);
				rc = -1;
			}
		}
	}
	else
		tupsz = -1;

	if (rc == 0)
	{
		char ch;
		int i = 0;

		while ((ch = *fmt++) != '\0' && ch != ')' && rc == 0)
		{
			PyObject *arg;
			int invalid = FALSE;

			if (tupsz > 0)
			{
				arg = PyTuple_GET_ITEM(res,i);
				++i;
			}
			else
				arg = res;

			switch (ch)
			{
			case 'a':
				{
					char **p = va_arg(va,char **);
					int *szp = va_arg(va,int *);

					if (arg == Py_None)
					{
						*p = NULL;
						*szp = 0;
					}
					else if (PyString_Check(arg))
					{
						*p = PyString_AS_STRING(arg);
						*szp = PyString_GET_SIZE(arg);
					}
					else
						invalid = TRUE;
				}

				break;

			case 'b':
				{
					int v = PyInt_AsLong(arg);

					if (PyErr_Occurred())
						invalid = TRUE;
					else
						sipSetBool(va_arg(va,void *),v);
				}

				break;

			case 'c':
				{
					if (PyString_Check(arg) && PyString_GET_SIZE(arg) == 1)
						*va_arg(va,char *) = *PyString_AS_STRING(arg);
					else
						invalid = TRUE;
				}

				break;

			case 'd':
				{
					double v = PyFloat_AsDouble(arg);

					if (PyErr_Occurred())
						invalid = TRUE;
					else
						*va_arg(va,double *) = v;
				}

				break;

			case 'e':
				{
					int v = PyInt_AsLong(arg);

					if (PyErr_Occurred())
						invalid = TRUE;
					else
						*va_arg(va,int *) = v;
				}

				break;

			case 'E':
				{
					PyTypeObject *et = va_arg(va, PyTypeObject *);
					int *p = va_arg(va, int *);

					if (PyObject_TypeCheck(arg, et))
						*p = PyInt_AsLong(arg);
					else
						invalid = TRUE;
				}

				break;

			case 'f':
				{
					float v = PyFloat_AsDouble(arg);

					if (PyErr_Occurred())
						invalid = TRUE;
					else
						*va_arg(va,float *) = v;
				}

				break;

			case 'h':
				{
					short v = PyInt_AsLong(arg);

					if (PyErr_Occurred())
						invalid = TRUE;
					else
						*va_arg(va,short *) = v;
				}

				break;

			case 't':
				{
					unsigned short v = sip_api_long_as_unsigned_long(arg);

					if (PyErr_Occurred())
						invalid = TRUE;
					else
						*va_arg(va,unsigned short *) = v;
				}

				break;

			case 'i':
				{
					int v = PyInt_AsLong(arg);

					if (PyErr_Occurred())
						invalid = TRUE;
					else
						*va_arg(va,int *) = v;
				}

				break;

			case 'u':
				{
					unsigned v = sip_api_long_as_unsigned_long(arg);

					if (PyErr_Occurred())
						invalid = TRUE;
					else
						*va_arg(va,unsigned *) = v;
				}

				break;

			case 'l':
				{
					long v = PyLong_AsLong(arg);

					if (PyErr_Occurred())
						invalid = TRUE;
					else
						*va_arg(va,long *) = v;
				}

				break;

			case 'm':
				{
					unsigned long v = sip_api_long_as_unsigned_long(arg);

					if (PyErr_Occurred())
						invalid = TRUE;
					else
						*va_arg(va, unsigned long *) = v;
				}

				break;

			case 'n':
				{
#if defined(HAVE_LONG_LONG)
					long long v = PyLong_AsLongLong(arg);
#else
					long v = PyLong_AsLong(arg);
#endif

					if (PyErr_Occurred())
						invalid = TRUE;
					else
#if defined(HAVE_LONG_LONG)
						*va_arg(va, long long *) = v;
#else
						*va_arg(va, long *) = v;
#endif
				}

				break;

			case 'o':
				{
#if defined(HAVE_LONG_LONG)
					unsigned long long v = PyLong_AsUnsignedLongLong(arg);
#else
					unsigned long v = PyLong_AsUnsignedLong(arg);
#endif

					if (PyErr_Occurred())
						invalid = TRUE;
					else
#if defined(HAVE_LONG_LONG)
						*va_arg(va, unsigned long long *) = v;
#else
						*va_arg(va, unsigned long *) = v;
#endif
				}

				break;

			case 's':
				{
					char **p = va_arg(va,char **);

					if (arg == Py_None)
						*p = NULL;
					else if (PyString_Check(arg))
						*p = PyString_AS_STRING(arg);
					else
						invalid = TRUE;
				}

				break;

			case 'C':
				{
					if (*fmt == '\0')
						invalid = TRUE;
					else
					{
						int flags = *fmt++ - '0';
						int iserr = FALSE;
						sipWrapperType *type;
						void **cpp;
						int *state;

						type = va_arg(va, sipWrapperType *);

						if (flags & FORMAT_NO_STATE)
							state = NULL;
						else
							state = va_arg(va, int *);

						cpp = va_arg(va, void **);

						*cpp = sip_api_force_convert_to_instance(arg, type, (flags & FORMAT_FACTORY ? arg : NULL), (flags & FORMAT_DEREF ? SIP_NOT_NONE : 0), state, &iserr);

						if (iserr)
							invalid = TRUE;
					}
				}

				break;

			case 'D':
				{
					if (*fmt == '\0')
						invalid = TRUE;
					else
					{
						int flags = *fmt++ - '0';
						int iserr = FALSE;
						const sipMappedType *mt;
						void **cpp;
						int *state;

						mt = va_arg(va, const sipMappedType *);

						if (flags & FORMAT_NO_STATE)
							state = NULL;
						else
							state = va_arg(va, int *);

						cpp = va_arg(va, void **);

						*cpp = sip_api_force_convert_to_mapped_type(arg, mt, (flags & FORMAT_FACTORY ? arg : NULL), (flags & FORMAT_DEREF ? SIP_NOT_NONE : 0), state, &iserr);

						if (iserr)
							invalid = TRUE;
					}
				}

				break;

			case 'L':
				{
					sipForceConvertToFunc func = va_arg(va,sipForceConvertToFunc);
					void **sipCpp = va_arg(va,void **);
					int iserr = FALSE;

					*sipCpp = func(arg,&iserr);

					if (iserr)
						invalid = TRUE;
				}

				break;

			case 'M':
				{
					sipForceConvertToFunc func = va_arg(va,sipForceConvertToFunc);
					void **sipCpp = va_arg(va,void **);
					int iserr = FALSE;

					*sipCpp = func(arg,&iserr);

					if (iserr || *sipCpp == NULL)
						invalid = TRUE;
				}

				break;

			case 'N':
				{
					PyTypeObject *type = va_arg(va,PyTypeObject *);
					PyObject **p = va_arg(va,PyObject **);

					if (arg == Py_None || PyObject_TypeCheck(arg,type))
					{
						Py_INCREF(arg);
						*p = arg;
					}
					else
						invalid = TRUE;
				}

				break;

			case 'O':
				Py_INCREF(arg);
				*va_arg(va,PyObject **) = arg;
				break;

			case 'T':
				{
					PyTypeObject *type = va_arg(va,PyTypeObject *);
					PyObject **p = va_arg(va,PyObject **);

					if (PyObject_TypeCheck(arg,type))
					{
						Py_INCREF(arg);
						*p = arg;
					}
					else
						invalid = TRUE;
				}

				break;

			case 'V':
				{
					void *v = sip_api_convert_to_void_ptr(arg);

					if (PyErr_Occurred())
						invalid = TRUE;
					else
						*va_arg(va,void **) = v;
				}

				break;

			case 'Z':
				if (arg != Py_None)
					invalid = TRUE;

				break;

			default:
				PyErr_Format(PyExc_SystemError,"sipParseResult(): invalid format character '%c'",ch);
				rc = -1;
			}

			if (invalid)
			{
				sip_api_bad_catcher_result(method);
				rc = -1;
				break;
			}
		}
	}

	va_end(va);

	if (isErr != NULL && rc < 0)
		*isErr = TRUE;

	return rc;
}


/*
 * A thin wrapper around PyLong_AsUnsignedLong() that works around a bug in
 * Python versions prior to v2.4 where an integer (or a named enum) causes an
 * error.
 */
static unsigned long sip_api_long_as_unsigned_long(PyObject *o)
{
#if PY_VERSION_HEX < 0x02040000
	if (o != NULL && !PyLong_Check(o) && PyInt_Check(o))
	{
		long v = PyInt_AsLong(o);

		if (v < 0)
		{
			PyErr_SetString(PyExc_OverflowError,
			"can't convert negative value to unsigned long");

			return (unsigned long)-1;
		}

		return v;
	}
#endif

	return PyLong_AsUnsignedLong(o);
}


/*
 * Parse the arguments to a C/C++ function without any side effects.
 */
static int sip_api_parse_args(int *argsParsedp,PyObject *sipArgs,char *fmt,...)
{
	int valid, nrargs, selfarg;
	sipWrapper *self;
	PyObject *single_arg;
	va_list va;

	/* Previous sticky errors stop subsequent parses. */
	if (*argsParsedp & PARSE_STICKY)
		return 0;

	/* See if we are parsing a tuple or a single argument. */
	if (PyTuple_Check(sipArgs))
	{
		Py_INCREF(sipArgs);
		nrargs = PyTuple_GET_SIZE(sipArgs);
	}
	else if ((single_arg = PyTuple_New(1)) != NULL)
	{
		Py_INCREF(sipArgs);
		PyTuple_SET_ITEM(single_arg,0,sipArgs);

		sipArgs = single_arg;
		nrargs = 1;
	}
	else
		return 0;

	/*
	 * The first pass checks all the types and does conversions that are
	 * cheap and have no side effects.
	 */
	va_start(va,fmt);
	valid = parsePass1(&self,&selfarg,&nrargs,sipArgs,fmt,va);
	va_end(va);

	if (valid != PARSE_OK)
	{
		int pvalid, pnrargs;

		/*
		 * Use this error if there was no previous error, or if we
		 * have parsed more arguments this time, or if the previous
		 * error was that there were too many arguments.
		 */
		pvalid = (*argsParsedp & PARSE_MASK);
		pnrargs = (*argsParsedp & ~PARSE_MASK);

		if (pvalid == PARSE_OK || pnrargs < nrargs ||
		    (pnrargs == nrargs && pvalid == PARSE_MANY))
			*argsParsedp = valid | nrargs;

		Py_DECREF(sipArgs);

		return 0;
	}

	/*
	 * The second pass does any remaining conversions now that we know we
	 * have the right signature.
	 */
	va_start(va,fmt);
	valid = parsePass2(self,selfarg,nrargs,sipArgs,fmt,va);
	va_end(va);

	if (valid != PARSE_OK)
	{
		*argsParsedp = valid | PARSE_STICKY;