remove more dead files
This commit is contained in:
Nguyen Anh Quynh
parent
5605522d15
commit
09d42b408a
@ -1,228 +0,0 @@
|
||||
/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
|
||||
|
||||
/*
|
||||
* schema-defined QAPI types
|
||||
*
|
||||
* Copyright IBM, Corp. 2011
|
||||
*
|
||||
* Authors:
|
||||
* Anthony Liguori <aliguori@us.ibm.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef QAPI_TYPES_H
|
||||
#define QAPI_TYPES_H
|
||||
|
||||
#include "unicorn/platform.h"
|
||||
|
||||
|
||||
#ifndef QAPI_TYPES_BUILTIN_STRUCT_DECL_H
|
||||
#define QAPI_TYPES_BUILTIN_STRUCT_DECL_H
|
||||
|
||||
|
||||
typedef struct strList
|
||||
{
|
||||
union {
|
||||
char *value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct strList *next;
|
||||
} strList;
|
||||
|
||||
typedef struct intList
|
||||
{
|
||||
union {
|
||||
int64_t value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct intList *next;
|
||||
} intList;
|
||||
|
||||
typedef struct numberList
|
||||
{
|
||||
union {
|
||||
double value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct numberList *next;
|
||||
} numberList;
|
||||
|
||||
typedef struct boolList
|
||||
{
|
||||
union {
|
||||
bool value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct boolList *next;
|
||||
} boolList;
|
||||
|
||||
typedef struct int8List
|
||||
{
|
||||
union {
|
||||
int8_t value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct int8List *next;
|
||||
} int8List;
|
||||
|
||||
typedef struct int16List
|
||||
{
|
||||
union {
|
||||
int16_t value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct int16List *next;
|
||||
} int16List;
|
||||
|
||||
typedef struct int32List
|
||||
{
|
||||
union {
|
||||
int32_t value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct int32List *next;
|
||||
} int32List;
|
||||
|
||||
typedef struct int64List
|
||||
{
|
||||
union {
|
||||
int64_t value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct int64List *next;
|
||||
} int64List;
|
||||
|
||||
typedef struct uint8List
|
||||
{
|
||||
union {
|
||||
uint8_t value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct uint8List *next;
|
||||
} uint8List;
|
||||
|
||||
typedef struct uint16List
|
||||
{
|
||||
union {
|
||||
uint16_t value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct uint16List *next;
|
||||
} uint16List;
|
||||
|
||||
typedef struct uint32List
|
||||
{
|
||||
union {
|
||||
uint32_t value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct uint32List *next;
|
||||
} uint32List;
|
||||
|
||||
typedef struct uint64List
|
||||
{
|
||||
union {
|
||||
uint64_t value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct uint64List *next;
|
||||
} uint64List;
|
||||
|
||||
#endif /* QAPI_TYPES_BUILTIN_STRUCT_DECL_H */
|
||||
|
||||
|
||||
extern const char *ErrorClass_lookup[];
|
||||
typedef enum ErrorClass
|
||||
{
|
||||
ERROR_CLASS_GENERIC_ERROR = 0,
|
||||
ERROR_CLASS_COMMAND_NOT_FOUND = 1,
|
||||
ERROR_CLASS_DEVICE_ENCRYPTED = 2,
|
||||
ERROR_CLASS_DEVICE_NOT_ACTIVE = 3,
|
||||
ERROR_CLASS_DEVICE_NOT_FOUND = 4,
|
||||
ERROR_CLASS_KVM_MISSING_CAP = 5,
|
||||
ERROR_CLASS_MAX = 6,
|
||||
} ErrorClass;
|
||||
|
||||
typedef struct ErrorClassList
|
||||
{
|
||||
union {
|
||||
ErrorClass value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct ErrorClassList *next;
|
||||
} ErrorClassList;
|
||||
|
||||
extern const char *X86CPURegister32_lookup[];
|
||||
typedef enum X86CPURegister32
|
||||
{
|
||||
X86_CPU_REGISTER32_EAX = 0,
|
||||
X86_CPU_REGISTER32_EBX = 1,
|
||||
X86_CPU_REGISTER32_ECX = 2,
|
||||
X86_CPU_REGISTER32_EDX = 3,
|
||||
X86_CPU_REGISTER32_ESP = 4,
|
||||
X86_CPU_REGISTER32_EBP = 5,
|
||||
X86_CPU_REGISTER32_ESI = 6,
|
||||
X86_CPU_REGISTER32_EDI = 7,
|
||||
X86_CPU_REGISTER32_MAX = 8,
|
||||
} X86CPURegister32;
|
||||
|
||||
typedef struct X86CPURegister32List
|
||||
{
|
||||
union {
|
||||
X86CPURegister32 value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct X86CPURegister32List *next;
|
||||
} X86CPURegister32List;
|
||||
|
||||
|
||||
typedef struct X86CPUFeatureWordInfo X86CPUFeatureWordInfo;
|
||||
|
||||
typedef struct X86CPUFeatureWordInfoList
|
||||
{
|
||||
union {
|
||||
X86CPUFeatureWordInfo *value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct X86CPUFeatureWordInfoList *next;
|
||||
} X86CPUFeatureWordInfoList;
|
||||
|
||||
#ifndef QAPI_TYPES_BUILTIN_CLEANUP_DECL_H
|
||||
#define QAPI_TYPES_BUILTIN_CLEANUP_DECL_H
|
||||
|
||||
void qapi_free_strList(strList *obj);
|
||||
void qapi_free_intList(intList *obj);
|
||||
void qapi_free_numberList(numberList *obj);
|
||||
void qapi_free_boolList(boolList *obj);
|
||||
void qapi_free_int8List(int8List *obj);
|
||||
void qapi_free_int16List(int16List *obj);
|
||||
void qapi_free_int32List(int32List *obj);
|
||||
void qapi_free_int64List(int64List *obj);
|
||||
void qapi_free_uint8List(uint8List *obj);
|
||||
void qapi_free_uint16List(uint16List *obj);
|
||||
void qapi_free_uint32List(uint32List *obj);
|
||||
void qapi_free_uint64List(uint64List *obj);
|
||||
|
||||
#endif /* QAPI_TYPES_BUILTIN_CLEANUP_DECL_H */
|
||||
|
||||
|
||||
void qapi_free_ErrorClassList(ErrorClassList *obj);
|
||||
|
||||
void qapi_free_X86CPURegister32List(X86CPURegister32List *obj);
|
||||
|
||||
struct X86CPUFeatureWordInfo
|
||||
{
|
||||
int64_t cpuid_input_eax;
|
||||
bool has_cpuid_input_ecx;
|
||||
int64_t cpuid_input_ecx;
|
||||
X86CPURegister32 cpuid_register;
|
||||
int64_t features;
|
||||
};
|
||||
|
||||
void qapi_free_X86CPUFeatureWordInfoList(X86CPUFeatureWordInfoList *obj);
|
||||
void qapi_free_X86CPUFeatureWordInfo(X86CPUFeatureWordInfo *obj);
|
||||
|
||||
#endif
|
||||
@ -1,51 +0,0 @@
|
||||
/* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
|
||||
|
||||
/*
|
||||
* schema-defined QAPI visitor functions
|
||||
*
|
||||
* Copyright IBM, Corp. 2011
|
||||
*
|
||||
* Authors:
|
||||
* Anthony Liguori <aliguori@us.ibm.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef QAPI_VISIT_H
|
||||
#define QAPI_VISIT_H
|
||||
|
||||
#include "qapi/visitor.h"
|
||||
#include "qapi-types.h"
|
||||
|
||||
|
||||
#ifndef QAPI_VISIT_BUILTIN_VISITOR_DECL_H
|
||||
#define QAPI_VISIT_BUILTIN_VISITOR_DECL_H
|
||||
|
||||
void visit_type_strList(Visitor *m, strList **obj, const char *name, Error **errp);
|
||||
void visit_type_intList(Visitor *m, intList **obj, const char *name, Error **errp);
|
||||
void visit_type_numberList(Visitor *m, numberList **obj, const char *name, Error **errp);
|
||||
void visit_type_boolList(Visitor *m, boolList **obj, const char *name, Error **errp);
|
||||
void visit_type_int8List(Visitor *m, int8List **obj, const char *name, Error **errp);
|
||||
void visit_type_int16List(Visitor *m, int16List **obj, const char *name, Error **errp);
|
||||
void visit_type_int32List(Visitor *m, int32List **obj, const char *name, Error **errp);
|
||||
void visit_type_int64List(Visitor *m, int64List **obj, const char *name, Error **errp);
|
||||
void visit_type_uint8List(Visitor *m, uint8List **obj, const char *name, Error **errp);
|
||||
void visit_type_uint16List(Visitor *m, uint16List **obj, const char *name, Error **errp);
|
||||
void visit_type_uint32List(Visitor *m, uint32List **obj, const char *name, Error **errp);
|
||||
void visit_type_uint64List(Visitor *m, uint64List **obj, const char *name, Error **errp);
|
||||
|
||||
#endif /* QAPI_VISIT_BUILTIN_VISITOR_DECL_H */
|
||||
|
||||
|
||||
void visit_type_ErrorClass(Visitor *m, ErrorClass *obj, const char *name, Error **errp);
|
||||
void visit_type_ErrorClassList(Visitor *m, ErrorClassList **obj, const char *name, Error **errp);
|
||||
|
||||
void visit_type_X86CPURegister32(Visitor *m, X86CPURegister32 *obj, const char *name, Error **errp);
|
||||
void visit_type_X86CPURegister32List(Visitor *m, X86CPURegister32List **obj, const char *name, Error **errp);
|
||||
|
||||
void visit_type_X86CPUFeatureWordInfo(Visitor *m, X86CPUFeatureWordInfo **obj, const char *name, Error **errp);
|
||||
void visit_type_X86CPUFeatureWordInfoList(Visitor *m, X86CPUFeatureWordInfoList **obj, const char *name, Error **errp);
|
||||
|
||||
#endif
|
||||
@ -1,132 +0,0 @@
|
||||
# Copyright (c) 2009 Raymond Hettinger
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person
|
||||
# obtaining a copy of this software and associated documentation files
|
||||
# (the "Software"), to deal in the Software without restriction,
|
||||
# including without limitation the rights to use, copy, modify, merge,
|
||||
# publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
# and to permit persons to whom the Software is furnished to do so,
|
||||
# subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be
|
||||
# included in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
# OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
try:
|
||||
from UserDict import UserDict
|
||||
from UserDict import DictMixin
|
||||
except ImportError:
|
||||
from collections import UserDict
|
||||
try:
|
||||
from collections import MutableMapping as DictMixin
|
||||
except ImportError:
|
||||
from collections.abc import MutableMapping as DictMixin
|
||||
|
||||
class OrderedDict(dict, DictMixin):
|
||||
|
||||
def __init__(self, *args, **kwds):
|
||||
if len(args) > 1:
|
||||
raise TypeError('expected at most 1 arguments, got %d' % len(args))
|
||||
try:
|
||||
self.__end
|
||||
except AttributeError:
|
||||
self.clear()
|
||||
self.update(*args, **kwds)
|
||||
|
||||
def clear(self):
|
||||
self.__end = end = []
|
||||
end += [None, end, end] # sentinel node for doubly linked list
|
||||
self.__map = {} # key --> [key, prev, next]
|
||||
dict.clear(self)
|
||||
|
||||
def __setitem__(self, key, value):
|
||||
if key not in self:
|
||||
end = self.__end
|
||||
curr = end[1]
|
||||
curr[2] = end[1] = self.__map[key] = [key, curr, end]
|
||||
dict.__setitem__(self, key, value)
|
||||
|
||||
def __delitem__(self, key):
|
||||
dict.__delitem__(self, key)
|
||||
key, prev, next = self.__map.pop(key)
|
||||
prev[2] = next
|
||||
next[1] = prev
|
||||
|
||||
def __iter__(self):
|
||||
end = self.__end
|
||||
curr = end[2]
|
||||
while curr is not end:
|
||||
yield curr[0]
|
||||
curr = curr[2]
|
||||
|
||||
def __reversed__(self):
|
||||
end = self.__end
|
||||
curr = end[1]
|
||||
while curr is not end:
|
||||
yield curr[0]
|
||||
curr = curr[1]
|
||||
|
||||
def popitem(self, last=True):
|
||||
if not self:
|
||||
raise KeyError('dictionary is empty')
|
||||
if last:
|
||||
key = reversed(self).next()
|
||||
else:
|
||||
key = iter(self).next()
|
||||
value = self.pop(key)
|
||||
return key, value
|
||||
|
||||
def __reduce__(self):
|
||||
items = [[k, self[k]] for k in self]
|
||||
tmp = self.__map, self.__end
|
||||
del self.__map, self.__end
|
||||
inst_dict = vars(self).copy()
|
||||
self.__map, self.__end = tmp
|
||||
if inst_dict:
|
||||
return (self.__class__, (items,), inst_dict)
|
||||
return self.__class__, (items,)
|
||||
|
||||
def keys(self):
|
||||
return list(self)
|
||||
|
||||
setdefault = DictMixin.setdefault
|
||||
update = DictMixin.update
|
||||
pop = DictMixin.pop
|
||||
values = DictMixin.values
|
||||
items = DictMixin.items
|
||||
|
||||
def __repr__(self):
|
||||
if not self:
|
||||
return '%s()' % (self.__class__.__name__,)
|
||||
return '%s(%r)' % (self.__class__.__name__, self.items())
|
||||
|
||||
def copy(self):
|
||||
return self.__class__(self)
|
||||
|
||||
@classmethod
|
||||
def fromkeys(cls, iterable, value=None):
|
||||
d = cls()
|
||||
for key in iterable:
|
||||
d[key] = value
|
||||
return d
|
||||
|
||||
def __eq__(self, other):
|
||||
if isinstance(other, OrderedDict):
|
||||
if len(self) != len(other):
|
||||
return False
|
||||
for p, q in zip(self.items(), other.items()):
|
||||
if p != q:
|
||||
return False
|
||||
return True
|
||||
return dict.__eq__(self, other)
|
||||
|
||||
def __ne__(self, other):
|
||||
return not self == other
|
||||
@ -1,14 +0,0 @@
|
||||
#!/bin/sh
|
||||
|
||||
# Run this scripts to create qapi below files in root dir
|
||||
# ../qapi-types.c
|
||||
# ../qapi-types.h
|
||||
# ../qapi-visit.c
|
||||
# ../qapi-visit.h
|
||||
|
||||
python qapi-types.py -h -o .. -b -i qapi-schema.json
|
||||
python qapi-types.py -c -o .. -b -i qapi-schema.json
|
||||
|
||||
python qapi-visit.py -h -o .. -b -i qapi-schema.json
|
||||
python qapi-visit.py -c -o .. -b -i qapi-schema.json
|
||||
|
||||
@ -1,39 +0,0 @@
|
||||
# -*- Mode: Python -*-
|
||||
#
|
||||
# QAPI Schema
|
||||
|
||||
# QAPI common definitions
|
||||
{ 'include': 'qapi/common.json' }
|
||||
|
||||
##
|
||||
# @X86CPURegister32
|
||||
#
|
||||
# A X86 32-bit register
|
||||
#
|
||||
# Since: 1.5
|
||||
##
|
||||
{ 'enum': 'X86CPURegister32',
|
||||
'data': [ 'EAX', 'EBX', 'ECX', 'EDX', 'ESP', 'EBP', 'ESI', 'EDI' ] }
|
||||
|
||||
##
|
||||
# @X86CPUFeatureWordInfo
|
||||
#
|
||||
# Information about a X86 CPU feature word
|
||||
#
|
||||
# @cpuid-input-eax: Input EAX value for CPUID instruction for that feature word
|
||||
#
|
||||
# @cpuid-input-ecx: #optional Input ECX value for CPUID instruction for that
|
||||
# feature word
|
||||
#
|
||||
# @cpuid-register: Output register containing the feature bits
|
||||
#
|
||||
# @features: value of output register, containing the feature bits
|
||||
#
|
||||
# Since: 1.5
|
||||
##
|
||||
{ 'type': 'X86CPUFeatureWordInfo',
|
||||
'data': { 'cpuid-input-eax': 'int',
|
||||
'*cpuid-input-ecx': 'int',
|
||||
'cpuid-register': 'X86CPURegister32',
|
||||
'features': 'int' } }
|
||||
|
||||
@ -1,464 +0,0 @@
|
||||
#
|
||||
# QAPI types generator
|
||||
#
|
||||
# Copyright IBM, Corp. 2011
|
||||
#
|
||||
# Authors:
|
||||
# Anthony Liguori <aliguori@us.ibm.com>
|
||||
#
|
||||
# This work is licensed under the terms of the GNU GPL, version 2.
|
||||
# See the COPYING file in the top-level directory.
|
||||
|
||||
from ordereddict import OrderedDict
|
||||
from qapi import *
|
||||
import sys
|
||||
import os
|
||||
import getopt
|
||||
import errno
|
||||
|
||||
def generate_fwd_struct(name, members, builtin_type=False):
|
||||
if builtin_type:
|
||||
return mcgen('''
|
||||
|
||||
typedef struct %(name)sList
|
||||
{
|
||||
union {
|
||||
%(type)s value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct %(name)sList *next;
|
||||
} %(name)sList;
|
||||
''',
|
||||
type=c_type(name),
|
||||
name=name)
|
||||
|
||||
return mcgen('''
|
||||
|
||||
typedef struct %(name)s %(name)s;
|
||||
|
||||
typedef struct %(name)sList
|
||||
{
|
||||
union {
|
||||
%(name)s *value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct %(name)sList *next;
|
||||
} %(name)sList;
|
||||
''',
|
||||
name=name)
|
||||
|
||||
def generate_fwd_enum_struct(name, members):
|
||||
return mcgen('''
|
||||
typedef struct %(name)sList
|
||||
{
|
||||
union {
|
||||
%(name)s value;
|
||||
uint64_t padding;
|
||||
};
|
||||
struct %(name)sList *next;
|
||||
} %(name)sList;
|
||||
''',
|
||||
name=name)
|
||||
|
||||
def generate_struct_fields(members):
|
||||
ret = ''
|
||||
|
||||
for argname, argentry, optional, structured in parse_args(members):
|
||||
if optional:
|
||||
ret += mcgen('''
|
||||
bool has_%(c_name)s;
|
||||
''',
|
||||
c_name=c_var(argname))
|
||||
if structured:
|
||||
push_indent()
|
||||
ret += generate_struct({ "field": argname, "data": argentry})
|
||||
pop_indent()
|
||||
else:
|
||||
ret += mcgen('''
|
||||
%(c_type)s %(c_name)s;
|
||||
''',
|
||||
c_type=c_type(argentry), c_name=c_var(argname))
|
||||
|
||||
return ret
|
||||
|
||||
def generate_struct(expr):
|
||||
|
||||
structname = expr.get('type', "")
|
||||
fieldname = expr.get('field', "")
|
||||
members = expr['data']
|
||||
base = expr.get('base')
|
||||
|
||||
ret = mcgen('''
|
||||
struct %(name)s
|
||||
{
|
||||
''',
|
||||
name=structname)
|
||||
|
||||
if base:
|
||||
ret += generate_struct_fields({'base': base})
|
||||
|
||||
ret += generate_struct_fields(members)
|
||||
|
||||
if len(fieldname):
|
||||
fieldname = " " + fieldname
|
||||
ret += mcgen('''
|
||||
}%(field)s;
|
||||
''',
|
||||
field=fieldname)
|
||||
|
||||
return ret
|
||||
|
||||
def generate_enum_lookup(name, values):
|
||||
ret = mcgen('''
|
||||
const char *%(name)s_lookup[] = {
|
||||
''',
|
||||
name=name)
|
||||
i = 0
|
||||
for value in values:
|
||||
ret += mcgen('''
|
||||
"%(value)s",
|
||||
''',
|
||||
value=value)
|
||||
|
||||
ret += mcgen('''
|
||||
NULL,
|
||||
};
|
||||
|
||||
''')
|
||||
return ret
|
||||
|
||||
def generate_enum(name, values):
|
||||
lookup_decl = mcgen('''
|
||||
extern const char *%(name)s_lookup[];
|
||||
''',
|
||||
name=name)
|
||||
|
||||
enum_decl = mcgen('''
|
||||
typedef enum %(name)s
|
||||
{
|
||||
''',
|
||||
name=name)
|
||||
|
||||
# append automatically generated _MAX value
|
||||
enum_values = values + [ 'MAX' ]
|
||||
|
||||
i = 0
|
||||
for value in enum_values:
|
||||
enum_full_value = generate_enum_full_value(name, value)
|
||||
enum_decl += mcgen('''
|
||||
%(enum_full_value)s = %(i)d,
|
||||
''',
|
||||
enum_full_value = enum_full_value,
|
||||
i=i)
|
||||
i += 1
|
||||
|
||||
enum_decl += mcgen('''
|
||||
} %(name)s;
|
||||
''',
|
||||
name=name)
|
||||
|
||||
return lookup_decl + enum_decl
|
||||
|
||||
def generate_anon_union_qtypes(expr):
|
||||
|
||||
name = expr['union']
|
||||
members = expr['data']
|
||||
|
||||
ret = mcgen('''
|
||||
const int %(name)s_qtypes[QTYPE_MAX] = {
|
||||
''',
|
||||
name=name)
|
||||
|
||||
for key in members:
|
||||
qapi_type = members[key]
|
||||
if qapi_type in builtin_type_qtypes:
|
||||
qtype = builtin_type_qtypes[qapi_type]
|
||||
elif find_struct(qapi_type):
|
||||
qtype = "QTYPE_QDICT"
|
||||
elif find_union(qapi_type):
|
||||
qtype = "QTYPE_QDICT"
|
||||
elif find_enum(qapi_type):
|
||||
qtype = "QTYPE_QSTRING"
|
||||
else:
|
||||
assert False, "Invalid anonymous union member"
|
||||
|
||||
ret += mcgen('''
|
||||
[ %(qtype)s ] = %(abbrev)s_KIND_%(enum)s,
|
||||
''',
|
||||
qtype = qtype,
|
||||
abbrev = de_camel_case(name).upper(),
|
||||
enum = c_fun(de_camel_case(key),False).upper())
|
||||
|
||||
ret += mcgen('''
|
||||
};
|
||||
''')
|
||||
return ret
|
||||
|
||||
|
||||
def generate_union(expr):
|
||||
|
||||
name = expr['union']
|
||||
typeinfo = expr['data']
|
||||
|
||||
base = expr.get('base')
|
||||
discriminator = expr.get('discriminator')
|
||||
|
||||
enum_define = discriminator_find_enum_define(expr)
|
||||
if enum_define:
|
||||
discriminator_type_name = enum_define['enum_name']
|
||||
else:
|
||||
discriminator_type_name = '%sKind' % (name)
|
||||
|
||||
ret = mcgen('''
|
||||
struct %(name)s
|
||||
{
|
||||
%(discriminator_type_name)s kind;
|
||||
union {
|
||||
void *data;
|
||||
''',
|
||||
name=name,
|
||||
discriminator_type_name=discriminator_type_name)
|
||||
|
||||
for key in typeinfo:
|
||||
ret += mcgen('''
|
||||
%(c_type)s %(c_name)s;
|
||||
''',
|
||||
c_type=c_type(typeinfo[key]),
|
||||
c_name=c_fun(key))
|
||||
|
||||
ret += mcgen('''
|
||||
};
|
||||
''')
|
||||
|
||||
if base:
|
||||
base_fields = find_struct(base)['data']
|
||||
if discriminator:
|
||||
base_fields = base_fields.copy()
|
||||
del base_fields[discriminator]
|
||||
ret += generate_struct_fields(base_fields)
|
||||
else:
|
||||
assert not discriminator
|
||||
|
||||
ret += mcgen('''
|
||||
};
|
||||
''')
|
||||
if discriminator == {}:
|
||||
ret += mcgen('''
|
||||
extern const int %(name)s_qtypes[];
|
||||
''',
|
||||
name=name)
|
||||
|
||||
|
||||
return ret
|
||||
|
||||
def generate_type_cleanup_decl(name):
|
||||
ret = mcgen('''
|
||||
void qapi_free_%(type)s(%(c_type)s obj);
|
||||
''',
|
||||
c_type=c_type(name),type=name)
|
||||
return ret
|
||||
|
||||
def generate_type_cleanup(name):
|
||||
ret = mcgen('''
|
||||
|
||||
void qapi_free_%(type)s(%(c_type)s obj)
|
||||
{
|
||||
QapiDeallocVisitor *md;
|
||||
Visitor *v;
|
||||
|
||||
if (!obj) {
|
||||
return;
|
||||
}
|
||||
|
||||
md = qapi_dealloc_visitor_new();
|
||||
v = qapi_dealloc_get_visitor(md);
|
||||
visit_type_%(type)s(v, &obj, NULL, NULL);
|
||||
qapi_dealloc_visitor_cleanup(md);
|
||||
}
|
||||
''',
|
||||
c_type=c_type(name),type=name)
|
||||
return ret
|
||||
|
||||
|
||||
try:
|
||||
opts, args = getopt.gnu_getopt(sys.argv[1:], "chbp:i:o:",
|
||||
["source", "header", "builtins",
|
||||
"prefix=", "input-file=", "output-dir="])
|
||||
except getopt.GetoptError as err:
|
||||
print(str(err))
|
||||
sys.exit(1)
|
||||
|
||||
output_dir = ""
|
||||
input_file = ""
|
||||
prefix = ""
|
||||
c_file = 'qapi-types.c'
|
||||
h_file = 'qapi-types.h'
|
||||
|
||||
do_c = False
|
||||
do_h = False
|
||||
do_builtins = False
|
||||
|
||||
for o, a in opts:
|
||||
if o in ("-p", "--prefix"):
|
||||
prefix = a
|
||||
elif o in ("-i", "--input-file"):
|
||||
input_file = a
|
||||
elif o in ("-o", "--output-dir"):
|
||||
output_dir = a + "/"
|
||||
elif o in ("-c", "--source"):
|
||||
do_c = True
|
||||
elif o in ("-h", "--header"):
|
||||
do_h = True
|
||||
elif o in ("-b", "--builtins"):
|
||||
do_builtins = True
|
||||
|
||||
if not do_c and not do_h:
|
||||
do_c = True
|
||||
do_h = True
|
||||
|
||||
c_file = output_dir + prefix + c_file
|
||||
h_file = output_dir + prefix + h_file
|
||||
|
||||
try:
|
||||
os.makedirs(output_dir)
|
||||
except os.error as e:
|
||||
if e.errno != errno.EEXIST:
|
||||
raise
|
||||
|
||||
def maybe_open(really, name, opt):
|
||||
if really:
|
||||
return open(name, opt)
|
||||
else:
|
||||
try:
|
||||
import StringIO
|
||||
return StringIO.StringIO()
|
||||
except ImportError:
|
||||
from io import StringIO
|
||||
return StringIO()
|
||||
|
||||
fdef = maybe_open(do_c, c_file, 'w')
|
||||
fdecl = maybe_open(do_h, h_file, 'w')
|
||||
|
||||
fdef.write(mcgen('''
|
||||
/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
|
||||
|
||||
/*
|
||||
* deallocation functions for schema-defined QAPI types
|
||||
*
|
||||
* Copyright IBM, Corp. 2011
|
||||
*
|
||||
* Authors:
|
||||
* Anthony Liguori <aliguori@us.ibm.com>
|
||||
* Michael Roth <mdroth@linux.vnet.ibm.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "qapi/dealloc-visitor.h"
|
||||
#include "%(prefix)sqapi-types.h"
|
||||
#include "%(prefix)sqapi-visit.h"
|
||||
|
||||
''', prefix=prefix))
|
||||
|
||||
fdecl.write(mcgen('''
|
||||
/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
|
||||
|
||||
/*
|
||||
* schema-defined QAPI types
|
||||
*
|
||||
* Copyright IBM, Corp. 2011
|
||||
*
|
||||
* Authors:
|
||||
* Anthony Liguori <aliguori@us.ibm.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef %(guard)s
|
||||
#define %(guard)s
|
||||
|
||||
#include "unicorn/platform.h"
|
||||
|
||||
''',
|
||||
guard=guardname(h_file)))
|
||||
|
||||
exprs = parse_schema(input_file)
|
||||
exprs = filter(lambda expr: 'gen' not in expr, exprs)
|
||||
exprs = list(exprs)
|
||||
|
||||
fdecl.write(guardstart("QAPI_TYPES_BUILTIN_STRUCT_DECL"))
|
||||
for typename in builtin_types:
|
||||
fdecl.write(generate_fwd_struct(typename, None, builtin_type=True))
|
||||
fdecl.write(guardend("QAPI_TYPES_BUILTIN_STRUCT_DECL"))
|
||||
|
||||
for expr in exprs:
|
||||
ret = "\n"
|
||||
if 'type' in expr:
|
||||
ret += generate_fwd_struct(expr['type'], expr['data'])
|
||||
elif 'enum' in expr:
|
||||
ret += generate_enum(expr['enum'], expr['data']) + "\n"
|
||||
ret += generate_fwd_enum_struct(expr['enum'], expr['data'])
|
||||
fdef.write(generate_enum_lookup(expr['enum'], expr['data']))
|
||||
elif 'union' in expr:
|
||||
ret += generate_fwd_struct(expr['union'], expr['data']) + "\n"
|
||||
enum_define = discriminator_find_enum_define(expr)
|
||||
if not enum_define:
|
||||
ret += generate_enum('%sKind' % expr['union'], expr['data'].keys())
|
||||
fdef.write(generate_enum_lookup('%sKind' % expr['union'],
|
||||
expr['data'].keys()))
|
||||
if expr.get('discriminator') == {}:
|
||||
fdef.write(generate_anon_union_qtypes(expr))
|
||||
else:
|
||||
continue
|
||||
fdecl.write(ret)
|
||||
|
||||
# to avoid header dependency hell, we always generate declarations
|
||||
# for built-in types in our header files and simply guard them
|
||||
fdecl.write(guardstart("QAPI_TYPES_BUILTIN_CLEANUP_DECL"))
|
||||
for typename in builtin_types:
|
||||
fdecl.write(generate_type_cleanup_decl(typename + "List"))
|
||||
fdecl.write(guardend("QAPI_TYPES_BUILTIN_CLEANUP_DECL"))
|
||||
|
||||
# ...this doesn't work for cases where we link in multiple objects that
|
||||
# have the functions defined, so we use -b option to provide control
|
||||
# over these cases
|
||||
if do_builtins:
|
||||
fdef.write(guardstart("QAPI_TYPES_BUILTIN_CLEANUP_DEF"))
|
||||
for typename in builtin_types:
|
||||
fdef.write(generate_type_cleanup(typename + "List"))
|
||||
fdef.write(guardend("QAPI_TYPES_BUILTIN_CLEANUP_DEF"))
|
||||
|
||||
for expr in exprs:
|
||||
ret = "\n"
|
||||
if 'type' in expr:
|
||||
ret += generate_struct(expr) + "\n"
|
||||
ret += generate_type_cleanup_decl(expr['type'] + "List")
|
||||
fdef.write(generate_type_cleanup(expr['type'] + "List") + "\n")
|
||||
ret += generate_type_cleanup_decl(expr['type'])
|
||||
fdef.write(generate_type_cleanup(expr['type']) + "\n")
|
||||
elif 'union' in expr:
|
||||
ret += generate_union(expr)
|
||||
ret += generate_type_cleanup_decl(expr['union'] + "List")
|
||||
fdef.write(generate_type_cleanup(expr['union'] + "List") + "\n")
|
||||
ret += generate_type_cleanup_decl(expr['union'])
|
||||
fdef.write(generate_type_cleanup(expr['union']) + "\n")
|
||||
elif 'enum' in expr:
|
||||
ret += generate_type_cleanup_decl(expr['enum'] + "List")
|
||||
fdef.write(generate_type_cleanup(expr['enum'] + "List") + "\n")
|
||||
else:
|
||||
continue
|
||||
fdecl.write(ret)
|
||||
|
||||
fdecl.write('''
|
||||
#endif
|
||||
''')
|
||||
|
||||
fdecl.flush()
|
||||
fdecl.close()
|
||||
|
||||
fdef.flush()
|
||||
fdef.close()
|
||||
@ -1,597 +0,0 @@
|
||||
#
|
||||
# QAPI visitor generator
|
||||
#
|
||||
# Copyright IBM, Corp. 2011
|
||||
# Copyright (C) 2014 Red Hat, Inc.
|
||||
#
|
||||
# Authors:
|
||||
# Anthony Liguori <aliguori@us.ibm.com>
|
||||
# Michael Roth <mdroth@linux.vnet.ibm.com>
|
||||
# Markus Armbruster <armbru@redhat.com>
|
||||
#
|
||||
# This work is licensed under the terms of the GNU GPL, version 2.
|
||||
# See the COPYING file in the top-level directory.
|
||||
|
||||
from ordereddict import OrderedDict
|
||||
from qapi import *
|
||||
import re
|
||||
import sys
|
||||
import os
|
||||
import getopt
|
||||
import errno
|
||||
|
||||
implicit_structs = []
|
||||
|
||||
def generate_visit_implicit_struct(type):
|
||||
global implicit_structs
|
||||
if type in implicit_structs:
|
||||
return ''
|
||||
implicit_structs.append(type)
|
||||
return mcgen('''
|
||||
|
||||
static void visit_type_implicit_%(c_type)s(Visitor *m, %(c_type)s **obj, Error **errp)
|
||||
{
|
||||
Error *err = NULL;
|
||||
|
||||
visit_start_implicit_struct(m, (void **)obj, sizeof(%(c_type)s), &err);
|
||||
if (!err) {
|
||||
visit_type_%(c_type)s_fields(m, obj, errp);
|
||||
visit_end_implicit_struct(m, &err);
|
||||
}
|
||||
error_propagate(errp, err);
|
||||
}
|
||||
''',
|
||||
c_type=type_name(type))
|
||||
|
||||
def generate_visit_struct_fields(name, field_prefix, fn_prefix, members, base = None):
|
||||
substructs = []
|
||||
ret = ''
|
||||
if not fn_prefix:
|
||||
full_name = name
|
||||
else:
|
||||
full_name = "%s_%s" % (name, fn_prefix)
|
||||
|
||||
for argname, argentry, optional, structured in parse_args(members):
|
||||
if structured:
|
||||
if not fn_prefix:
|
||||
nested_fn_prefix = argname
|
||||
else:
|
||||
nested_fn_prefix = "%s_%s" % (fn_prefix, argname)
|
||||
|
||||
nested_field_prefix = "%s%s." % (field_prefix, argname)
|
||||
ret += generate_visit_struct_fields(name, nested_field_prefix,
|
||||
nested_fn_prefix, argentry)
|
||||
ret += mcgen('''
|
||||
|
||||
static void visit_type_%(full_name)s_field_%(c_name)s(Visitor *m, %(name)s **obj, Error **errp)
|
||||
{
|
||||
''',
|
||||
name=name, full_name=full_name, c_name=c_var(argname))
|
||||
ret += generate_visit_struct_body(full_name, argname, argentry)
|
||||
ret += mcgen('''
|
||||
}
|
||||
''')
|
||||
|
||||
if base:
|
||||
ret += generate_visit_implicit_struct(base)
|
||||
|
||||
ret += mcgen('''
|
||||
|
||||
static void visit_type_%(full_name)s_fields(Visitor *m, %(name)s **obj, Error **errp)
|
||||
{
|
||||
Error *err = NULL;
|
||||
''',
|
||||
name=name, full_name=full_name)
|
||||
push_indent()
|
||||
|
||||
if base:
|
||||
ret += mcgen('''
|
||||
visit_type_implicit_%(type)s(m, &(*obj)->%(c_prefix)s%(c_name)s, &err);
|
||||
if (err) {
|
||||
goto out;
|
||||
}
|
||||
''',
|
||||
c_prefix=c_var(field_prefix),
|
||||
type=type_name(base), c_name=c_var('base'))
|
||||
|
||||
for argname, argentry, optional, structured in parse_args(members):
|
||||
if optional:
|
||||
ret += mcgen('''
|
||||
visit_optional(m, &(*obj)->%(c_prefix)shas_%(c_name)s, "%(name)s", &err);
|
||||
if (!err && (*obj)->%(prefix)shas_%(c_name)s) {
|
||||
''',
|
||||
c_prefix=c_var(field_prefix), prefix=field_prefix,
|
||||
c_name=c_var(argname), name=argname)
|
||||
push_indent()
|
||||
|
||||
if structured:
|
||||
ret += mcgen('''
|
||||
visit_type_%(full_name)s_field_%(c_name)s(m, obj, &err);
|
||||
''',
|
||||
full_name=full_name, c_name=c_var(argname))
|
||||
else:
|
||||
ret += mcgen('''
|
||||
visit_type_%(type)s(m, &(*obj)->%(c_prefix)s%(c_name)s, "%(name)s", &err);
|
||||
''',
|
||||
c_prefix=c_var(field_prefix), prefix=field_prefix,
|
||||
type=type_name(argentry), c_name=c_var(argname),
|
||||
name=argname)
|
||||
|
||||
if optional:
|
||||
pop_indent()
|
||||
ret += mcgen('''
|
||||
}
|
||||
''')
|
||||
ret += mcgen('''
|
||||
if (err) {
|
||||
goto out;
|
||||
}
|
||||
''')
|
||||
|
||||
pop_indent()
|
||||
if re.search('^ *goto out\\;', ret, re.MULTILINE):
|
||||
ret += mcgen('''
|
||||
|
||||
out:
|
||||
''')
|
||||
ret += mcgen('''
|
||||
error_propagate(errp, err);
|
||||
}
|
||||
''')
|
||||
return ret
|
||||
|
||||
|
||||
def generate_visit_struct_body(field_prefix, name, members):
|
||||
ret = mcgen('''
|
||||
Error *err = NULL;
|
||||
|
||||
''')
|
||||
|
||||
if not field_prefix:
|
||||
full_name = name
|
||||
else:
|
||||
full_name = "%s_%s" % (field_prefix, name)
|
||||
|
||||
if len(field_prefix):
|
||||
ret += mcgen('''
|
||||
visit_start_struct(m, NULL, "", "%(name)s", 0, &err);
|
||||
''',
|
||||
name=name)
|
||||
else:
|
||||
ret += mcgen('''
|
||||
visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(name)s), &err);
|
||||
''',
|
||||
name=name)
|
||||
|
||||
ret += mcgen('''
|
||||
if (!err) {
|
||||
if (*obj) {
|
||||
visit_type_%(name)s_fields(m, obj, errp);
|
||||
}
|
||||
visit_end_struct(m, &err);
|
||||
}
|
||||
error_propagate(errp, err);
|
||||
''',
|
||||
name=full_name)
|
||||
|
||||
return ret
|
||||
|
||||
def generate_visit_struct(expr):
|
||||
|
||||
name = expr['type']
|
||||
members = expr['data']
|
||||
base = expr.get('base')
|
||||
|
||||
ret = generate_visit_struct_fields(name, "", "", members, base)
|
||||
|
||||
ret += mcgen('''
|
||||
|
||||
void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp)
|
||||
{
|
||||
''',
|
||||
name=name)
|
||||
|
||||
ret += generate_visit_struct_body("", name, members)
|
||||
|
||||
ret += mcgen('''
|
||||
}
|
||||
''')
|
||||
return ret
|
||||
|
||||
def generate_visit_list(name, members):
|
||||
return mcgen('''
|
||||
|
||||
void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp)
|
||||
{
|
||||
Error *err = NULL;
|
||||
GenericList *i, **prev;
|
||||
|
||||
visit_start_list(m, name, &err);
|
||||
if (err) {
|
||||
goto out;
|
||||
}
|
||||
|
||||
for (prev = (GenericList **)obj;
|
||||
!err && (i = visit_next_list(m, prev, &err)) != NULL;
|
||||
prev = &i) {
|
||||
%(name)sList *native_i = (%(name)sList *)i;
|
||||
visit_type_%(name)s(m, &native_i->value, NULL, &err);
|
||||
}
|
||||
|
||||
error_propagate(errp, err);
|
||||
err = NULL;
|
||||
visit_end_list(m, &err);
|
||||
out:
|
||||
error_propagate(errp, err);
|
||||
}
|
||||
''',
|
||||
name=name)
|
||||
|
||||
def generate_visit_enum(name, members):
|
||||
return mcgen('''
|
||||
|
||||
void visit_type_%(name)s(Visitor *m, %(name)s *obj, const char *name, Error **errp)
|
||||
{
|
||||
visit_type_enum(m, (int *)obj, %(name)s_lookup, "%(name)s", name, errp);
|
||||
}
|
||||
''',
|
||||
name=name)
|
||||
|
||||
def generate_visit_anon_union(name, members):
|
||||
ret = mcgen('''
|
||||
|
||||
void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp)
|
||||
{
|
||||
Error *err = NULL;
|
||||
|
||||
visit_start_implicit_struct(m, (void**) obj, sizeof(%(name)s), &err);
|
||||
if (err) {
|
||||
goto out;
|
||||
}
|
||||
visit_get_next_type(m, (int*) &(*obj)->kind, %(name)s_qtypes, name, &err);
|
||||
if (err) {
|
||||
goto out_end;
|
||||
}
|
||||
switch ((*obj)->kind) {
|
||||
''',
|
||||
name=name)
|
||||
|
||||
# For anon union, always use the default enum type automatically generated
|
||||
# as "'%sKind' % (name)"
|
||||
disc_type = '%sKind' % (name)
|
||||
|
||||
for key in members:
|
||||
assert (members[key] in builtin_types
|
||||
or find_struct(members[key])
|
||||
or find_union(members[key])
|
||||
or find_enum(members[key])), "Invalid anonymous union member"
|
||||
|
||||
enum_full_value = generate_enum_full_value(disc_type, key)
|
||||
ret += mcgen('''
|
||||
case %(enum_full_value)s:
|
||||
visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, name, &err);
|
||||
break;
|
||||
''',
|
||||
enum_full_value = enum_full_value,
|
||||
c_type = type_name(members[key]),
|
||||
c_name = c_fun(key))
|
||||
|
||||
ret += mcgen('''
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
out_end:
|
||||
error_propagate(errp, err);
|
||||
err = NULL;
|
||||
visit_end_implicit_struct(m, &err);
|
||||
out:
|
||||
error_propagate(errp, err);
|
||||
}
|
||||
''')
|
||||
|
||||
return ret
|
||||
|
||||
|
||||
def generate_visit_union(expr):
|
||||
|
||||
name = expr['union']
|
||||
members = expr['data']
|
||||
|
||||
base = expr.get('base')
|
||||
discriminator = expr.get('discriminator')
|
||||
|
||||
if discriminator == {}:
|
||||
assert not base
|
||||
return generate_visit_anon_union(name, members)
|
||||
|
||||
enum_define = discriminator_find_enum_define(expr)
|
||||
if enum_define:
|
||||
# Use the enum type as discriminator
|
||||
ret = ""
|
||||
disc_type = enum_define['enum_name']
|
||||
else:
|
||||
# There will always be a discriminator in the C switch code, by default it
|
||||
# is an enum type generated silently as "'%sKind' % (name)"
|
||||
ret = generate_visit_enum('%sKind' % name, members.keys())
|
||||
disc_type = '%sKind' % (name)
|
||||
|
||||
if base:
|
||||
base_fields = find_struct(base)['data']
|
||||
if discriminator:
|
||||
base_fields = base_fields.copy()
|
||||
del base_fields[discriminator]
|
||||
ret += generate_visit_struct_fields(name, "", "", base_fields)
|
||||
|
||||
if discriminator:
|
||||
for key in members:
|
||||
ret += generate_visit_implicit_struct(members[key])
|
||||
|
||||
ret += mcgen('''
|
||||
|
||||
void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp)
|
||||
{
|
||||
Error *err = NULL;
|
||||
|
||||
visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(name)s), &err);
|
||||
if (err) {
|
||||
goto out;
|
||||
}
|
||||
if (*obj) {
|
||||
''',
|
||||
name=name)
|
||||
|
||||
if base:
|
||||
ret += mcgen('''
|
||||
visit_type_%(name)s_fields(m, obj, &err);
|
||||
if (err) {
|
||||
goto out_obj;
|
||||
}
|
||||
''',
|
||||
name=name)
|
||||
|
||||
if not discriminator:
|
||||
disc_key = "type"
|
||||
else:
|
||||
disc_key = discriminator
|
||||
ret += mcgen('''
|
||||
visit_type_%(disc_type)s(m, &(*obj)->kind, "%(disc_key)s", &err);
|
||||
if (err) {
|
||||
goto out_obj;
|
||||
}
|
||||
if (!visit_start_union(m, !!(*obj)->data, &err) || err) {
|
||||
goto out_obj;
|
||||
}
|
||||
switch ((*obj)->kind) {
|
||||
''',
|
||||
disc_type = disc_type,
|
||||
disc_key = disc_key)
|
||||
|
||||
for key in members:
|
||||
if not discriminator:
|
||||
fmt = 'visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, "data", &err);'
|
||||
else:
|
||||
fmt = 'visit_type_implicit_%(c_type)s(m, &(*obj)->%(c_name)s, &err);'
|
||||
|
||||
enum_full_value = generate_enum_full_value(disc_type, key)
|
||||
ret += mcgen('''
|
||||
case %(enum_full_value)s:
|
||||
''' + fmt + '''
|
||||
break;
|
||||
''',
|
||||
enum_full_value = enum_full_value,
|
||||
c_type=type_name(members[key]),
|
||||
c_name=c_fun(key))
|
||||
|
||||
ret += mcgen('''
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
out_obj:
|
||||
error_propagate(errp, err);
|
||||
err = NULL;
|
||||
visit_end_union(m, !!(*obj)->data, &err);
|
||||
error_propagate(errp, err);
|
||||
err = NULL;
|
||||
}
|
||||
visit_end_struct(m, &err);
|
||||
out:
|
||||
error_propagate(errp, err);
|
||||
}
|
||||
''')
|
||||
|
||||
return ret
|
||||
|
||||
def generate_declaration(name, members, genlist=True, builtin_type=False):
|
||||
ret = ""
|
||||
if not builtin_type:
|
||||
ret += mcgen('''
|
||||
|
||||
void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp);
|
||||
''',
|
||||
name=name)
|
||||
|
||||
if genlist:
|
||||
ret += mcgen('''
|
||||
void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp);
|
||||
''',
|
||||
name=name)
|
||||
|
||||
return ret
|
||||
|
||||
def generate_enum_declaration(name, members, genlist=True):
|
||||
ret = ""
|
||||
if genlist:
|
||||
ret += mcgen('''
|
||||
void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp);
|
||||
''',
|
||||
name=name)
|
||||
|
||||
return ret
|
||||
|
||||
def generate_decl_enum(name, members, genlist=True):
|
||||
return mcgen('''
|
||||
|
||||
void visit_type_%(name)s(Visitor *m, %(name)s *obj, const char *name, Error **errp);
|
||||
''',
|
||||
name=name)
|
||||
|
||||
try:
|
||||
opts, args = getopt.gnu_getopt(sys.argv[1:], "chbp:i:o:",
|
||||
["source", "header", "builtins", "prefix=",
|
||||
"input-file=", "output-dir="])
|
||||
except getopt.GetoptError as err:
|
||||
print(str(err))
|
||||
sys.exit(1)
|
||||
|
||||
input_file = ""
|
||||
output_dir = ""
|
||||
prefix = ""
|
||||
c_file = 'qapi-visit.c'
|
||||
h_file = 'qapi-visit.h'
|
||||
|
||||
do_c = False
|
||||
do_h = False
|
||||
do_builtins = False
|
||||
|
||||
for o, a in opts:
|
||||
if o in ("-p", "--prefix"):
|
||||
prefix = a
|
||||
elif o in ("-i", "--input-file"):
|
||||
input_file = a
|
||||
elif o in ("-o", "--output-dir"):
|
||||
output_dir = a + "/"
|
||||
elif o in ("-c", "--source"):
|
||||
do_c = True
|
||||
elif o in ("-h", "--header"):
|
||||
do_h = True
|
||||
elif o in ("-b", "--builtins"):
|
||||
do_builtins = True
|
||||
|
||||
if not do_c and not do_h:
|
||||
do_c = True
|
||||
do_h = True
|
||||
|
||||
c_file = output_dir + prefix + c_file
|
||||
h_file = output_dir + prefix + h_file
|
||||
|
||||
try:
|
||||
os.makedirs(output_dir)
|
||||
except os.error as e:
|
||||
if e.errno != errno.EEXIST:
|
||||
raise
|
||||
|
||||
def maybe_open(really, name, opt):
|
||||
if really:
|
||||
return open(name, opt)
|
||||
else:
|
||||
try:
|
||||
import StringIO
|
||||
return StringIO.StringIO()
|
||||
except ImportError:
|
||||
from io import StringIO
|
||||
return StringIO()
|
||||
|
||||
fdef = maybe_open(do_c, c_file, 'w')
|
||||
fdecl = maybe_open(do_h, h_file, 'w')
|
||||
|
||||
fdef.write(mcgen('''
|
||||
/* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
|
||||
|
||||
/*
|
||||
* schema-defined QAPI visitor functions
|
||||
*
|
||||
* Copyright IBM, Corp. 2011
|
||||
*
|
||||
* Authors:
|
||||
* Anthony Liguori <aliguori@us.ibm.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "qemu-common.h"
|
||||
#include "%(header)s"
|
||||
''',
|
||||
header=basename(h_file)))
|
||||
|
||||
fdecl.write(mcgen('''
|
||||
/* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
|
||||
|
||||
/*
|
||||
* schema-defined QAPI visitor functions
|
||||
*
|
||||
* Copyright IBM, Corp. 2011
|
||||
*
|
||||
* Authors:
|
||||
* Anthony Liguori <aliguori@us.ibm.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef %(guard)s
|
||||
#define %(guard)s
|
||||
|
||||
#include "qapi/visitor.h"
|
||||
#include "%(prefix)sqapi-types.h"
|
||||
|
||||
''',
|
||||
prefix=prefix, guard=guardname(h_file)))
|
||||
|
||||
exprs = parse_schema(input_file)
|
||||
|
||||
# to avoid header dependency hell, we always generate declarations
|
||||
# for built-in types in our header files and simply guard them
|
||||
fdecl.write(guardstart("QAPI_VISIT_BUILTIN_VISITOR_DECL"))
|
||||
for typename in builtin_types:
|
||||
fdecl.write(generate_declaration(typename, None, genlist=True,
|
||||
builtin_type=True))
|
||||
fdecl.write(guardend("QAPI_VISIT_BUILTIN_VISITOR_DECL"))
|
||||
|
||||
# ...this doesn't work for cases where we link in multiple objects that
|
||||
# have the functions defined, so we use -b option to provide control
|
||||
# over these cases
|
||||
if do_builtins:
|
||||
for typename in builtin_types:
|
||||
fdef.write(generate_visit_list(typename, None))
|
||||
|
||||
for expr in exprs:
|
||||
if 'type' in expr:
|
||||
ret = generate_visit_struct(expr)
|
||||
ret += generate_visit_list(expr['type'], expr['data'])
|
||||
fdef.write(ret)
|
||||
|
||||
ret = generate_declaration(expr['type'], expr['data'])
|
||||
fdecl.write(ret)
|
||||
elif 'union' in expr:
|
||||
ret = generate_visit_union(expr)
|
||||
ret += generate_visit_list(expr['union'], expr['data'])
|
||||
fdef.write(ret)
|
||||
|
||||
enum_define = discriminator_find_enum_define(expr)
|
||||
ret = ""
|
||||
if not enum_define:
|
||||
ret = generate_decl_enum('%sKind' % expr['union'],
|
||||
expr['data'].keys())
|
||||
ret += generate_declaration(expr['union'], expr['data'])
|
||||
fdecl.write(ret)
|
||||
elif 'enum' in expr:
|
||||
ret = generate_visit_list(expr['enum'], expr['data'])
|
||||
ret += generate_visit_enum(expr['enum'], expr['data'])
|
||||
fdef.write(ret)
|
||||
|
||||
ret = generate_decl_enum(expr['enum'], expr['data'])
|
||||
ret += generate_enum_declaration(expr['enum'], expr['data'])
|
||||
fdecl.write(ret)
|
||||
|
||||
fdecl.write('''
|
||||
#endif
|
||||
''')
|
||||
|
||||
fdecl.flush()
|
||||
fdecl.close()
|
||||
|
||||
fdef.flush()
|
||||
fdef.close()
|
||||
@ -1,605 +0,0 @@
|
||||
#
|
||||
# QAPI helper library
|
||||
#
|
||||
# Copyright IBM, Corp. 2011
|
||||
# Copyright (c) 2013 Red Hat Inc.
|
||||
#
|
||||
# Authors:
|
||||
# Anthony Liguori <aliguori@us.ibm.com>
|
||||
# Markus Armbruster <armbru@redhat.com>
|
||||
#
|
||||
# This work is licensed under the terms of the GNU GPL, version 2.
|
||||
# See the COPYING file in the top-level directory.
|
||||
|
||||
import re
|
||||
from ordereddict import OrderedDict
|
||||
import os
|
||||
import sys
|
||||
|
||||
try:
|
||||
basestring
|
||||
except NameError:
|
||||
basestring = str
|
||||
|
||||
builtin_types = [
|
||||
'str', 'int', 'number', 'bool',
|
||||
'int8', 'int16', 'int32', 'int64',
|
||||
'uint8', 'uint16', 'uint32', 'uint64'
|
||||
]
|
||||
|
||||
builtin_type_qtypes = {
|
||||
'str': 'QTYPE_QSTRING',
|
||||
'int': 'QTYPE_QINT',
|
||||
'number': 'QTYPE_QFLOAT',
|
||||
'bool': 'QTYPE_QBOOL',
|
||||
'int8': 'QTYPE_QINT',
|
||||
'int16': 'QTYPE_QINT',
|
||||
'int32': 'QTYPE_QINT',
|
||||
'int64': 'QTYPE_QINT',
|
||||
'uint8': 'QTYPE_QINT',
|
||||
'uint16': 'QTYPE_QINT',
|
||||
'uint32': 'QTYPE_QINT',
|
||||
'uint64': 'QTYPE_QINT',
|
||||
}
|
||||
|
||||
def error_path(parent):
|
||||
res = ""
|
||||
while parent:
|
||||
res = ("In file included from %s:%d:\n" % (parent['file'],
|
||||
parent['line'])) + res
|
||||
parent = parent['parent']
|
||||
return res
|
||||
|
||||
class QAPISchemaError(Exception):
|
||||
def __init__(self, schema, msg):
|
||||
self.input_file = schema.input_file
|
||||
self.msg = msg
|
||||
self.col = 1
|
||||
self.line = schema.line
|
||||
for ch in schema.src[schema.line_pos:schema.pos]:
|
||||
if ch == '\t':
|
||||
self.col = (self.col + 7) % 8 + 1
|
||||
else:
|
||||
self.col += 1
|
||||
self.info = schema.parent_info
|
||||
|
||||
def __str__(self):
|
||||
return error_path(self.info) + \
|
||||
"%s:%d:%d: %s" % (self.input_file, self.line, self.col, self.msg)
|
||||
|
||||
class QAPIExprError(Exception):
|
||||
def __init__(self, expr_info, msg):
|
||||
self.info = expr_info
|
||||
self.msg = msg
|
||||
|
||||
def __str__(self):
|
||||
return error_path(self.info['parent']) + \
|
||||
"%s:%d: %s" % (self.info['file'], self.info['line'], self.msg)
|
||||
|
||||
class QAPISchema:
|
||||
|
||||
def __init__(self, fp, input_relname=None, include_hist=[],
|
||||
previously_included=[], parent_info=None):
|
||||
""" include_hist is a stack used to detect inclusion cycles
|
||||
previously_included is a global state used to avoid multiple
|
||||
inclusions of the same file"""
|
||||
input_fname = os.path.abspath(fp.name)
|
||||
if input_relname is None:
|
||||
input_relname = fp.name
|
||||
self.input_dir = os.path.dirname(input_fname)
|
||||
self.input_file = input_relname
|
||||
self.include_hist = include_hist + [(input_relname, input_fname)]
|
||||
previously_included.append(input_fname)
|
||||
self.parent_info = parent_info
|
||||
self.src = fp.read()
|
||||
if self.src == '' or self.src[-1] != '\n':
|
||||
self.src += '\n'
|
||||
self.cursor = 0
|
||||
self.line = 1
|
||||
self.line_pos = 0
|
||||
self.exprs = []
|
||||
self.accept()
|
||||
|
||||
while self.tok != None:
|
||||
expr_info = {'file': input_relname, 'line': self.line, 'parent': self.parent_info}
|
||||
expr = self.get_expr(False)
|
||||
if isinstance(expr, dict) and "include" in expr:
|
||||
if len(expr) != 1:
|
||||
raise QAPIExprError(expr_info, "Invalid 'include' directive")
|
||||
include = expr["include"]
|
||||
if not isinstance(include, str):
|
||||
raise QAPIExprError(expr_info,
|
||||
'Expected a file name (string), got: %s'
|
||||
% include)
|
||||
include_path = os.path.join(self.input_dir, include)
|
||||
for elem in self.include_hist:
|
||||
if include_path == elem[1]:
|
||||
raise QAPIExprError(expr_info, "Inclusion loop for %s"
|
||||
% include)
|
||||
# skip multiple include of the same file
|
||||
if include_path in previously_included:
|
||||
continue
|
||||
try:
|
||||
fobj = open(include_path, 'r')
|
||||
except IOError as e:
|
||||
raise QAPIExprError(expr_info,
|
||||
'%s: %s' % (e.strerror, include))
|
||||
exprs_include = QAPISchema(fobj, include, self.include_hist,
|
||||
previously_included, expr_info)
|
||||
self.exprs.extend(exprs_include.exprs)
|
||||
else:
|
||||
expr_elem = {'expr': expr,
|
||||
'info': expr_info}
|
||||
self.exprs.append(expr_elem)
|
||||
|
||||
def accept(self):
|
||||
while True:
|
||||
self.tok = self.src[self.cursor]
|
||||
self.pos = self.cursor
|
||||
self.cursor += 1
|
||||
self.val = None
|
||||
|
||||
if self.tok == '#':
|
||||
self.cursor = self.src.find('\n', self.cursor)
|
||||
elif self.tok in ['{', '}', ':', ',', '[', ']']:
|
||||
return
|
||||
elif self.tok == "'":
|
||||
string = ''
|
||||
esc = False
|
||||
while True:
|
||||
ch = self.src[self.cursor]
|
||||
self.cursor += 1
|
||||
if ch == '\n':
|
||||
raise QAPISchemaError(self,
|
||||
'Missing terminating "\'"')
|
||||
if esc:
|
||||
string += ch
|
||||
esc = False
|
||||
elif ch == "\\":
|
||||
esc = True
|
||||
elif ch == "'":
|
||||
self.val = string
|
||||
return
|
||||
else:
|
||||
string += ch
|
||||
elif self.tok == '\n':
|
||||
if self.cursor == len(self.src):
|
||||
self.tok = None
|
||||
return
|
||||
self.line += 1
|
||||
self.line_pos = self.cursor
|
||||
elif not self.tok.isspace():
|
||||
raise QAPISchemaError(self, 'Stray "%s"' % self.tok)
|
||||
|
||||
def get_members(self):
|
||||
expr = OrderedDict()
|
||||
if self.tok == '}':
|
||||
self.accept()
|
||||
return expr
|
||||
if self.tok != "'":
|
||||
raise QAPISchemaError(self, 'Expected string or "}"')
|
||||
while True:
|
||||
key = self.val
|
||||
self.accept()
|
||||
if self.tok != ':':
|
||||
raise QAPISchemaError(self, 'Expected ":"')
|
||||
self.accept()
|
||||
if key in expr:
|
||||
raise QAPISchemaError(self, 'Duplicate key "%s"' % key)
|
||||
expr[key] = self.get_expr(True)
|
||||
if self.tok == '}':
|
||||
self.accept()
|
||||
return expr
|
||||
if self.tok != ',':
|
||||
raise QAPISchemaError(self, 'Expected "," or "}"')
|
||||
self.accept()
|
||||
if self.tok != "'":
|
||||
raise QAPISchemaError(self, 'Expected string')
|
||||
|
||||
def get_values(self):
|
||||
expr = []
|
||||
if self.tok == ']':
|
||||
self.accept()
|
||||
return expr
|
||||
if not self.tok in [ '{', '[', "'" ]:
|
||||
raise QAPISchemaError(self, 'Expected "{", "[", "]" or string')
|
||||
while True:
|
||||
expr.append(self.get_expr(True))
|
||||
if self.tok == ']':
|
||||
self.accept()
|
||||
return expr
|
||||
if self.tok != ',':
|
||||
raise QAPISchemaError(self, 'Expected "," or "]"')
|
||||
self.accept()
|
||||
|
||||
def get_expr(self, nested):
|
||||
if self.tok != '{' and not nested:
|
||||
raise QAPISchemaError(self, 'Expected "{"')
|
||||
if self.tok == '{':
|
||||
self.accept()
|
||||
expr = self.get_members()
|
||||
elif self.tok == '[':
|
||||
self.accept()
|
||||
expr = self.get_values()
|
||||
elif self.tok == "'":
|
||||
expr = self.val
|
||||
self.accept()
|
||||
else:
|
||||
raise QAPISchemaError(self, 'Expected "{", "[" or string')
|
||||
return expr
|
||||
|
||||
def find_base_fields(base):
|
||||
base_struct_define = find_struct(base)
|
||||
if not base_struct_define:
|
||||
return None
|
||||
return base_struct_define['data']
|
||||
|
||||
# Return the discriminator enum define if discriminator is specified as an
|
||||
# enum type, otherwise return None.
|
||||
def discriminator_find_enum_define(expr):
|
||||
base = expr.get('base')
|
||||
discriminator = expr.get('discriminator')
|
||||
|
||||
if not (discriminator and base):
|
||||
return None
|
||||
|
||||
base_fields = find_base_fields(base)
|
||||
if not base_fields:
|
||||
return None
|
||||
|
||||
discriminator_type = base_fields.get(discriminator)
|
||||
if not discriminator_type:
|
||||
return None
|
||||
|
||||
return find_enum(discriminator_type)
|
||||
|
||||
def check_event(expr, expr_info):
|
||||
params = expr.get('data')
|
||||
if params:
|
||||
for argname, argentry, optional, structured in parse_args(params):
|
||||
if structured:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Nested structure define in event is not "
|
||||
"supported, event '%s', argname '%s'"
|
||||
% (expr['event'], argname))
|
||||
|
||||
def check_union(expr, expr_info):
|
||||
name = expr['union']
|
||||
base = expr.get('base')
|
||||
discriminator = expr.get('discriminator')
|
||||
members = expr['data']
|
||||
|
||||
# If the object has a member 'base', its value must name a complex type.
|
||||
if base:
|
||||
base_fields = find_base_fields(base)
|
||||
if not base_fields:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Base '%s' is not a valid type"
|
||||
% base)
|
||||
|
||||
# If the union object has no member 'discriminator', it's an
|
||||
# ordinary union.
|
||||
if not discriminator:
|
||||
enum_define = None
|
||||
|
||||
# Else if the value of member 'discriminator' is {}, it's an
|
||||
# anonymous union.
|
||||
elif discriminator == {}:
|
||||
enum_define = None
|
||||
|
||||
# Else, it's a flat union.
|
||||
else:
|
||||
# The object must have a member 'base'.
|
||||
if not base:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Flat union '%s' must have a base field"
|
||||
% name)
|
||||
# The value of member 'discriminator' must name a member of the
|
||||
# base type.
|
||||
discriminator_type = base_fields.get(discriminator)
|
||||
if not discriminator_type:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Discriminator '%s' is not a member of base "
|
||||
"type '%s'"
|
||||
% (discriminator, base))
|
||||
enum_define = find_enum(discriminator_type)
|
||||
# Do not allow string discriminator
|
||||
if not enum_define:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Discriminator '%s' must be of enumeration "
|
||||
"type" % discriminator)
|
||||
|
||||
# Check every branch
|
||||
for (key, value) in members.items():
|
||||
# If this named member's value names an enum type, then all members
|
||||
# of 'data' must also be members of the enum type.
|
||||
if enum_define and not key in enum_define['enum_values']:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Discriminator value '%s' is not found in "
|
||||
"enum '%s'" %
|
||||
(key, enum_define["enum_name"]))
|
||||
# Todo: add checking for values. Key is checked as above, value can be
|
||||
# also checked here, but we need more functions to handle array case.
|
||||
|
||||
def check_exprs(schema):
|
||||
for expr_elem in schema.exprs:
|
||||
expr = expr_elem['expr']
|
||||
if 'union' in expr:
|
||||
check_union(expr, expr_elem['info'])
|
||||
if 'event' in expr:
|
||||
check_event(expr, expr_elem['info'])
|
||||
|
||||
def parse_schema(input_file):
|
||||
try:
|
||||
schema = QAPISchema(open(input_file, "r"))
|
||||
except (QAPISchemaError, QAPIExprError) as e:
|
||||
print >>sys.stderr, e
|
||||
exit(1)
|
||||
|
||||
exprs = []
|
||||
|
||||
for expr_elem in schema.exprs:
|
||||
expr = expr_elem['expr']
|
||||
if 'enum' in expr:
|
||||
add_enum(expr['enum'], expr['data'])
|
||||
elif 'union' in expr:
|
||||
add_union(expr)
|
||||
elif 'type' in expr:
|
||||
add_struct(expr)
|
||||
exprs.append(expr)
|
||||
|
||||
# Try again for hidden UnionKind enum
|
||||
for expr_elem in schema.exprs:
|
||||
expr = expr_elem['expr']
|
||||
if 'union' in expr:
|
||||
if not discriminator_find_enum_define(expr):
|
||||
add_enum('%sKind' % expr['union'])
|
||||
|
||||
try:
|
||||
check_exprs(schema)
|
||||
except QAPIExprError as e:
|
||||
print >>sys.stderr, e
|
||||
exit(1)
|
||||
|
||||
return exprs
|
||||
|
||||
def parse_args(typeinfo):
|
||||
if isinstance(typeinfo, basestring):
|
||||
struct = find_struct(typeinfo)
|
||||
assert struct != None
|
||||
typeinfo = struct['data']
|
||||
|
||||
for member in typeinfo:
|
||||
argname = member
|
||||
argentry = typeinfo[member]
|
||||
optional = False
|
||||
structured = False
|
||||
if member.startswith('*'):
|
||||
argname = member[1:]
|
||||
optional = True
|
||||
if isinstance(argentry, OrderedDict):
|
||||
structured = True
|
||||
yield (argname, argentry, optional, structured)
|
||||
|
||||
def de_camel_case(name):
|
||||
new_name = ''
|
||||
for ch in name:
|
||||
if ch.isupper() and new_name:
|
||||
new_name += '_'
|
||||
if ch == '-':
|
||||
new_name += '_'
|
||||
else:
|
||||
new_name += ch.lower()
|
||||
return new_name
|
||||
|
||||
def camel_case(name):
|
||||
new_name = ''
|
||||
first = True
|
||||
for ch in name:
|
||||
if ch in ['_', '-']:
|
||||
first = True
|
||||
elif first:
|
||||
new_name += ch.upper()
|
||||
first = False
|
||||
else:
|
||||
new_name += ch.lower()
|
||||
return new_name
|
||||
|
||||
def c_var(name, protect=True):
|
||||
# ANSI X3J11/88-090, 3.1.1
|
||||
c89_words = set(['auto', 'break', 'case', 'char', 'const', 'continue',
|
||||
'default', 'do', 'double', 'else', 'enum', 'extern', 'float',
|
||||
'for', 'goto', 'if', 'int', 'long', 'register', 'return',
|
||||
'short', 'signed', 'sizeof', 'static', 'struct', 'switch',
|
||||
'typedef', 'union', 'unsigned', 'void', 'volatile', 'while'])
|
||||
# ISO/IEC 9899:1999, 6.4.1
|
||||
c99_words = set(['inline', 'restrict', '_Bool', '_Complex', '_Imaginary'])
|
||||
# ISO/IEC 9899:2011, 6.4.1
|
||||
c11_words = set(['_Alignas', '_Alignof', '_Atomic', '_Generic', '_Noreturn',
|
||||
'_Static_assert', '_Thread_local'])
|
||||
# GCC http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/C-Extensions.html
|
||||
# excluding _.*
|
||||
gcc_words = set(['asm', 'typeof'])
|
||||
# C++ ISO/IEC 14882:2003 2.11
|
||||
cpp_words = set(['bool', 'catch', 'class', 'const_cast', 'delete',
|
||||
'dynamic_cast', 'explicit', 'false', 'friend', 'mutable',
|
||||
'namespace', 'new', 'operator', 'private', 'protected',
|
||||
'public', 'reinterpret_cast', 'static_cast', 'template',
|
||||
'this', 'throw', 'true', 'try', 'typeid', 'typename',
|
||||
'using', 'virtual', 'wchar_t',
|
||||
# alternative representations
|
||||
'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not',
|
||||
'not_eq', 'or', 'or_eq', 'xor', 'xor_eq'])
|
||||
# namespace pollution:
|
||||
polluted_words = set(['unix', 'errno'])
|
||||
if protect and (name in c89_words | c99_words | c11_words | gcc_words | cpp_words | polluted_words):
|
||||
return "q_" + name
|
||||
return name.replace('-', '_').lstrip("*")
|
||||
|
||||
def c_fun(name, protect=True):
|
||||
return c_var(name, protect).replace('.', '_')
|
||||
|
||||
def c_list_type(name):
|
||||
return '%sList' % name
|
||||
|
||||
def type_name(name):
|
||||
if type(name) == list:
|
||||
return c_list_type(name[0])
|
||||
return name
|
||||
|
||||
enum_types = []
|
||||
struct_types = []
|
||||
union_types = []
|
||||
|
||||
def add_struct(definition):
|
||||
global struct_types
|
||||
struct_types.append(definition)
|
||||
|
||||
def find_struct(name):
|
||||
global struct_types
|
||||
for struct in struct_types:
|
||||
if struct['type'] == name:
|
||||
return struct
|
||||
return None
|
||||
|
||||
def add_union(definition):
|
||||
global union_types
|
||||
union_types.append(definition)
|
||||
|
||||
def find_union(name):
|
||||
global union_types
|
||||
for union in union_types:
|
||||
if union['union'] == name:
|
||||
return union
|
||||
return None
|
||||
|
||||
def add_enum(name, enum_values = None):
|
||||
global enum_types
|
||||
enum_types.append({"enum_name": name, "enum_values": enum_values})
|
||||
|
||||
def find_enum(name):
|
||||
global enum_types
|
||||
for enum in enum_types:
|
||||
if enum['enum_name'] == name:
|
||||
return enum
|
||||
return None
|
||||
|
||||
def is_enum(name):
|
||||
return find_enum(name) != None
|
||||
|
||||
eatspace = '\033EATSPACE.'
|
||||
|
||||
# A special suffix is added in c_type() for pointer types, and it's
|
||||
# stripped in mcgen(). So please notice this when you check the return
|
||||
# value of c_type() outside mcgen().
|
||||
def c_type(name, is_param=False):
|
||||
if name == 'str':
|
||||
if is_param:
|
||||
return 'const char *' + eatspace
|
||||
return 'char *' + eatspace
|
||||
|
||||
elif name == 'int':
|
||||
return 'int64_t'
|
||||
elif (name == 'int8' or name == 'int16' or name == 'int32' or
|
||||
name == 'int64' or name == 'uint8' or name == 'uint16' or
|
||||
name == 'uint32' or name == 'uint64'):
|
||||
return name + '_t'
|
||||
elif name == 'size':
|
||||
return 'uint64_t'
|
||||
elif name == 'bool':
|
||||
return 'bool'
|
||||
elif name == 'number':
|
||||
return 'double'
|
||||
elif type(name) == list:
|
||||
return '%s *%s' % (c_list_type(name[0]), eatspace)
|
||||
elif is_enum(name):
|
||||
return name
|
||||
elif name == None or len(name) == 0:
|
||||
return 'void'
|
||||
elif name == name.upper():
|
||||
return '%sEvent *%s' % (camel_case(name), eatspace)
|
||||
else:
|
||||
return '%s *%s' % (name, eatspace)
|
||||
|
||||
def is_c_ptr(name):
|
||||
suffix = "*" + eatspace
|
||||
return c_type(name).endswith(suffix)
|
||||
|
||||
def genindent(count):
|
||||
ret = ""
|
||||
for i in range(count):
|
||||
ret += " "
|
||||
return ret
|
||||
|
||||
indent_level = 0
|
||||
|
||||
def push_indent(indent_amount=4):
|
||||
global indent_level
|
||||
indent_level += indent_amount
|
||||
|
||||
def pop_indent(indent_amount=4):
|
||||
global indent_level
|
||||
indent_level -= indent_amount
|
||||
|
||||
def cgen(code, **kwds):
|
||||
indent = genindent(indent_level)
|
||||
lines = code.split('\n')
|
||||
lines = map(lambda x: indent + x, lines)
|
||||
return '\n'.join(lines) % kwds + '\n'
|
||||
|
||||
def mcgen(code, **kwds):
|
||||
raw = cgen('\n'.join(code.split('\n')[1:-1]), **kwds)
|
||||
return re.sub(re.escape(eatspace) + ' *', '', raw)
|
||||
|
||||
def basename(filename):
|
||||
return filename.split("/")[-1]
|
||||
|
||||
def guardname(filename):
|
||||
guard = basename(filename).rsplit(".", 1)[0]
|
||||
for substr in [".", " ", "-"]:
|
||||
guard = guard.replace(substr, "_")
|
||||
return guard.upper() + '_H'
|
||||
|
||||
def guardstart(name):
|
||||
return mcgen('''
|
||||
|
||||
#ifndef %(name)s
|
||||
#define %(name)s
|
||||
|
||||
''',
|
||||
name=guardname(name))
|
||||
|
||||
def guardend(name):
|
||||
return mcgen('''
|
||||
|
||||
#endif /* %(name)s */
|
||||
|
||||
''',
|
||||
name=guardname(name))
|
||||
|
||||
# ENUMName -> ENUM_NAME, EnumName1 -> ENUM_NAME1
|
||||
# ENUM_NAME -> ENUM_NAME, ENUM_NAME1 -> ENUM_NAME1, ENUM_Name2 -> ENUM_NAME2
|
||||
# ENUM24_Name -> ENUM24_NAME
|
||||
def _generate_enum_string(value):
|
||||
c_fun_str = c_fun(value, False)
|
||||
if value.isupper():
|
||||
return c_fun_str
|
||||
|
||||
new_name = ''
|
||||
l = len(c_fun_str)
|
||||
for i in range(l):
|
||||
c = c_fun_str[i]
|
||||
# When c is upper and no "_" appears before, do more checks
|
||||
if c.isupper() and (i > 0) and c_fun_str[i - 1] != "_":
|
||||
# Case 1: next string is lower
|
||||
# Case 2: previous string is digit
|
||||
if (i < (l - 1) and c_fun_str[i + 1].islower()) or \
|
||||
c_fun_str[i - 1].isdigit():
|
||||
new_name += '_'
|
||||
new_name += c
|
||||
return new_name.lstrip('_').upper()
|
||||
|
||||
def generate_enum_full_value(enum_name, enum_value):
|
||||
abbrev_string = _generate_enum_string(enum_name)
|
||||
value_string = _generate_enum_string(enum_value)
|
||||
return "%s_%s" % (abbrev_string, value_string)
|
||||
@ -1,30 +0,0 @@
|
||||
# -*- Mode: Python -*-
|
||||
#
|
||||
# QAPI common definitions
|
||||
|
||||
##
|
||||
# @ErrorClass
|
||||
#
|
||||
# QEMU error classes
|
||||
#
|
||||
# @GenericError: this is used for errors that don't require a specific error
|
||||
# class. This should be the default case for most errors
|
||||
#
|
||||
# @CommandNotFound: the requested command has not been found
|
||||
#
|
||||
# @DeviceEncrypted: the requested operation can't be fulfilled because the
|
||||
# selected device is encrypted
|
||||
#
|
||||
# @DeviceNotActive: a device has failed to be become active
|
||||
#
|
||||
# @DeviceNotFound: the requested device has not been found
|
||||
#
|
||||
# @KVMMissingCap: the requested operation can't be fulfilled because a
|
||||
# required KVM capability is missing
|
||||
#
|
||||
# Since: 1.2
|
||||
##
|
||||
{ 'enum': 'ErrorClass',
|
||||
'data': [ 'GenericError', 'CommandNotFound', 'DeviceEncrypted',
|
||||
'DeviceNotActive', 'DeviceNotFound', 'KVMMissingCap' ] }
|
||||
|
||||
Loading…
Reference in New Issue
Block a user