- Shiboken
- » Type System Reference

# Type System Variables

User written code can be placed in arbitrary places using the inject-code tag. To ease the binding developer work, the injected code can make use of special variables that will be replaced by the correct values. This also shields the developer from some Qt for Python implementation specifics.

## Variables

%0

  Replaced by the C++ return variable of the Python method/function wrapper.

%<number>

  Replaced by the name of a C++ argument in the position indicated by `<number>`. The argument counting starts with `%1`, since `%0` represents the return variable name. If the number indicates a variable that was removed in the type system description, but there is a default value for it, this value will be used. Consider this example:

      void argRemoval(int a0, int a1 = 123);

      <modify-function signature="argRemoval(int, int)">
          <modify-argument index="2">
              <remove-argument/>
          </modify-argument>
      </modify-function>

  The `%1` will be replaced by the C++ argument name, and `%2` will get the value `123`.

%ARGUMENT_NAMES

  Replaced by a comma separated list with the names of all C++ arguments that were not removed on the type system description for the method/function. When the removed argument has a default value (original or provided in the type system), this value will be inserted in the argument list. If you want to remove the argument so completely that it doesn’t appear in any form on the `%ARGUMENT_NAMES` replacement, don’t forget to remove also its default value with the remove-default-expression type system tag.

  Take the following method and related type system description as an example:

      void argRemoval(int a0, Point a1 = Point(1, 2), bool a2 = true, Point a3 = Point(3, 4), int a4 = 56);

      <modify-function signature="argRemoval(int, Point, bool, Point, int)">
          <modify-argument index="2">
              <remove-argument/>
              <replace-default-expression with="Point(6, 9)"/>
          </modify-argument>
          <modify-argument index="4">
              <remove-argument/>
          </modify-argument>
      </modify-function>

  As seen on the XML description, the function’s `a1` and `a3` arguments were removed. If any `inject-code` for this function uses `%ARGUMENT_NAMES` the resulting list will be the equivalent of using individual argument type system variables this way:

      %1, Point(6, 9), %3, Point(3, 4), %5

%ARG#_TYPE

  Replaced by the type of a C++ argument in the position indicated by `#`. The argument counting starts with `%1`, since `%0` represents the return variable in other contexts, but `%ARG0_TYPE` will not translate to the return type, as this is already done by the %RETURN_TYPE variable. Example:

      void argRemoval(int a0, int a1 = 123);

      <modify-function signature="argRemoval(int, int)">
          <modify-argument index="2">
              <remove-argument/>
          </modify-argument>
      </modify-function>

  The `%1` will be replaced by the C++ argument name, and `%2` will get the value `123`.

%CONVERTTOCPP[CPPTYPE]

  Replaced by a Qt for Python conversion call that converts a Python variable to a C++ variable of the type indicated by `CPPTYPE`.

  Typically, this is a variable assignment:

      double value = %CONVERTTOCPP[double](pyValue);

  Pointer assignments are also possible:

      void f(double *valuePtr)
      {
          *valuePtr = %CONVERTTOCPP[double](pyValue);

  Note however, that for variable definitions, the type must be a space-delimited token:

      double * valuePtr = %CONVERTTOCPP[double](pyValue);

  since it otherwise would be indistinguishable from the pointer assignment above.

  It is possible to use “auto” as type.

%CONVERTTOPYTHON[CPPTYPE]

  Replaced by a Qt for Python conversion call that converts a C++ variable of the type indicated by `CPPTYPE` to the proper Python object.

%ISCONVERTIBLE[CPPTYPE]

  Replaced by a Qt for Python “isConvertible” call that checks if a Python variable is convertible (via an implicit conversion or cast operator call) to a C++ variable of the type indicated by `CPPTYPE`.

%CHECKTYPE[CPPTYPE]

  Replaced by a Qt for Python “checkType” call that verifies if a Python if of the type indicated by `CPPTYPE`.

%CPPSELF

  Replaced by the wrapped C++ object instance that owns the method in which the code with this variable was inserted.

%CPPTYPE

  Replaced by the original name of the C++ class, without any namespace prefix, that owns the method in which the code with this variable was inserted. It will work on class level code injections also. Notice that `CPPTYPE` differs from the %TYPE variable, for this latter may be translated to the original C++ class name or to the C++ wrapper class name.

  Namespaces will are treated as classes, so `CPPTYPE` will work for them and their enclosed functions as well.

%FUNCTION_NAME

  Replaced by the name of a function or method.

%PYARG_0

  Replaced by the name of the Python return variable of the Python method/function wrapper.

%PYARG_<number>

  Similar to `%<number>`, but is replaced by the Python arguments (PyObjects) received by the Python wrapper method.

  If used in the context of a native code injection, i.e. in a virtual method override, `%PYARG_<number>` will be translated to one item of the Python tuple holding the arguments that should be passed to the Python override for this virtual method.

  The example

      long a = PyLong_AS_LONG(%PYARG_1);

  is equivalent of

      long a = PyLong_AS_LONG(PyTuple_GetItem(%PYTHON_ARGUMENTS, 0));

  The generator tries to be smart with attributions, but it will work for the only simplest cases.

  This example

      Py_DECREF(%PYARG_1);
      %PYARG_1 = PyLong_FromLong(10);

  is equivalent of

      Py_DECREF(PyTuple_GetItem(%PYTHON_ARGUMENTS, 0));
      PyTuple_SetItem(%PYTHON_ARGUMENTS, 0, PyLong_FromLong(10));

%PYSELF

  Replaced by the Python wrapper variable (a PyObject) representing the instance bounded to the Python wrapper method which receives the custom code.

%PYTHON_ARGUMENTS

  Replaced by the pointer to the Python tuple with Python objects converted from the C++ arguments received on the binding override of a virtual method. This tuple is the same passed as arguments to the Python method overriding the C++ parent’s one.

%PYTHON_METHOD_OVERRIDE

  This variable is used only on native method code injections, i.e. on the binding overrides for C++ virtual methods. It is replaced by a pointer to the Python method override.

%PYTHONTYPEOBJECT

  Replaced by the Python type object for the context in which it is inserted: method or class modification.

%BEGIN_ALLOW_THREADS

  Replaced by a thread state saving procedure. Must match with a %END_ALLOW_THREADS variable.

%END_ALLOW_THREADS

  Replaced by a thread state restoring procedure. Must match with a %BEGIN_ALLOW_THREADS variable.

%RETURN_TYPE

  Replaced by the type returned by a function or method.

%TYPE

  Replaced by the name of the class to which a function belongs. May be used in code injected at method or class level.

## Example

Just to illustrate the usage of the variables described in the previous sections, below is an excerpt from the type system description of a Qt for Python test. It changes a method that received `argc/argv` arguments into something that expects a Python sequence instead.

    <modify-function signature="overloadedMethod(int, char**)">
        <modify-argument index="1">
            <replace-type modified-type="PySequence" />
        </modify-argument>
        <modify-argument index="2">
            <remove-argument />
        </modify-argument>
        <inject-code class="target" position="beginning">
            int argc;
            char** argv;
            if (!PySequence_to_argc_argv(%PYARG_1, &amp;argc, &amp;argv)) {
                PyErr_SetString(PyExc_TypeError, "error");
                return 0;
            }
            %RETURN_TYPE foo = %CPPSELF.%FUNCTION_NAME(argc, argv);
            %0 = %CONVERTTOPYTHON[%RETURN_TYPE](foo);

            for (int i = 0; i &lt; argc; ++i)
                delete[] argv[i];
            delete[] argv;
        </inject-code>
    </modify-function>