qapi: Pseudo-type '**' is now unused, drop it

separated by a hyphen.  However, some existing older commands and

complex types use underscore; when extending such expressions,

consistency is preferred over blindly avoiding underscore.  Event

names should be ALL_CAPS with words separated by underscore.  The

special string '**' appears for some commands that manually perform

their own type checking rather than relying on the type-safe code

produced by the qapi code generators.

names should be ALL_CAPS with words separated by underscore.

Any name (command, event, type, field, or enum value) beginning with

"x-" is marked experimental, and may be withdrawn or changed

 <= { "return": [ { "value": "one" }, { } ] }

In rare cases, QAPI cannot express a type-safe representation of a

corresponding Client JSON Protocol command.  In these cases, if the

command expression includes the key 'gen' with boolean value false,

then the 'data' or 'returns' member that intends to bypass generated

type-safety and do its own manual validation should use an inline

dictionary definition, with a value of '**' rather than a valid type

name for the keys that the generated code will not validate.  Please

try to avoid adding new commands that rely on this, and instead use

type-safe unions.  For an example of bypass usage:

corresponding Client JSON Protocol command.  You then have to suppress

generation of a marshalling function by including a key 'gen' with

boolean value false, and instead write your own function.  Please try

to avoid adding new commands that rely on this, and instead use

type-safe unions.  For an example of this usage:

 { 'command': 'netdev_add',

   'data': {'type': 'str', 'id': 'str'},

def check_type(expr_info, source, value, allow_array = False,

               allow_dict = False, allow_optional = False,

               allow_star = False, allow_metas = []):

               allow_metas = []):

    global all_names

    if value is None:

        return

    if allow_star and value == '**':

        return

    # Check if array type for value is okay

    if isinstance(value, list):

        if not allow_array:

    # Check if type name for value is okay

    if isinstance(value, str):

        if value == '**':

            raise QAPIExprError(expr_info,

                                "%s uses '**' but did not request 'gen':false"

                                % source)

        if not value in all_names:

            raise QAPIExprError(expr_info,

                                "%s uses unknown type '%s'"

        # Todo: allow dictionaries to represent default values of

        # an optional argument.

        check_type(expr_info, "Member '%s' of %s" % (key, source), arg,

                   allow_array=True, allow_star=allow_star,

                   allow_array=True,

                   allow_metas=['built-in', 'union', 'alternate', 'struct',

                                'enum'])

def check_command(expr, expr_info):

    name = expr['command']

    allow_star = expr.has_key('gen')

    check_type(expr_info, "'data' for command '%s'" % name,

               expr.get('data'), allow_dict=True, allow_optional=True,

               allow_metas=['struct'], allow_star=allow_star)

               allow_metas=['struct'])

    returns_meta = ['union', 'struct']

    if name in returns_whitelist:

        returns_meta += ['built-in', 'alternate', 'enum']

    check_type(expr_info, "'returns' for command '%s'" % name,

               expr.get('returns'), allow_array=True,

               allow_optional=True, allow_metas=returns_meta,

               allow_star=allow_star)

               allow_optional=True, allow_metas=returns_meta)

def check_event(expr, expr_info):

    global events

                  ('bool',   'boolean', 'bool',     'false'),

                  ('any',    'value',   'QObject' + pointer_suffix, 'NULL')]:

            self._def_builtin_type(*t)

        self._entity_dict['**'] = self.lookup_type('any') # TODO drop this alias

    def _make_implicit_enum_type(self, name, values):

        name = name + 'Kind'

    def visit(self, visitor):

        visitor.visit_begin(self)

        for name in sorted(self._entity_dict.keys()):

            if self._entity_dict[name].name != name:

                continue        # ignore alias TODO drop alias and remove

            self._entity_dict[name].visit(visitor)

        visitor.visit_end()

	bad-type-dict.json double-data.json unknown-expr-key.json \

	redefined-type.json redefined-command.json redefined-builtin.json \

	redefined-event.json command-int.json bad-data.json event-max.json \

	type-bypass.json type-bypass-no-gen.json type-bypass-bad-gen.json \

	type-bypass-bad-gen.json \

	args-invalid.json \

	args-array-empty.json args-array-unknown.json args-int.json \

	args-unknown.json args-member-unknown.json args-member-array.json \

tests/qapi-schema/type-bypass-no-gen.json:2: Member 'arg' of 'data' for command 'unsafe' uses '**' but did not request 'gen':false

1