From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:44653) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YsscH-0003Oo-Pu for qemu-devel@nongnu.org; Thu, 14 May 2015 08:51:59 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1YsscG-00046z-J0 for qemu-devel@nongnu.org; Thu, 14 May 2015 08:51:57 -0400 Received: from mx1.redhat.com ([209.132.183.28]:48041) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YsscG-00045s-CI for qemu-devel@nongnu.org; Thu, 14 May 2015 08:51:56 -0400 From: Eric Blake Date: Thu, 14 May 2015 06:50:55 -0600 Message-Id: <1431607862-9238-10-git-send-email-eblake@redhat.com> In-Reply-To: <1431607862-9238-1-git-send-email-eblake@redhat.com> References: <1431607862-9238-1-git-send-email-eblake@redhat.com> Subject: [Qemu-devel] [PATCH v4 09/16] qapi: Make c_type() consistently convert qapi names List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: kwolf@redhat.com, akong@redhat.com, berto@igalia.com, armbru@redhat.com, mdroth@linux.vnet.ibm.com Continuing the string of cleanups for supporting downstream names containing '.', this patch focuses on ensuring c_type() can handle a downstream name. This patch alone does not fix the places where generator output should be calling this function but was open-coding things instead, but it gets us a step closer. In particular, the changes to c_list_type() and type_name() mean that type_name(FOO) now handles the case when FOO contains '.', '-', or is a ticklish identifier other than a builtin (builtins are exempted because ['int'] must remain mapped to 'intList' and not 'q_intList'). Meanwhile, ['unix'] now maps to 'q_unixList' rather than 'unixList', to match the fact that 'unix' is ticklish; however, our naming conventions state that complex types should start with a capital, so no type name following conventions will ever have the 'q_' prepended. Likewise, changes to c_type() mean that c_type(FOO) properly handles an enum or complex type FOO with '.' or '-' in the name, or is a ticklish identifier (again, a ticklish identifier as a type name violates conventions). Signed-off-by: Eric Blake --- v4: more comments based on feedback from Markus; rebase atop inserted patch with parameter rename --- scripts/qapi.py | 33 +++++++++++++++++++++++++++++---- 1 file changed, 29 insertions(+), 4 deletions(-) diff --git a/scripts/qapi.py b/scripts/qapi.py index 85e5d00..309dfec 100644 --- a/scripts/qapi.py +++ b/scripts/qapi.py @@ -769,6 +769,15 @@ def c_enum_const(type_name, const_name): c_name_trans = string.maketrans('.-', '__') +# Map @name to a valid C identifier. +# If @protect, avoid returning certain ticklish identifiers (like +# C keywords) by prepending "q_". +# +# Used for converting 'name' from a 'name':'type' qapi definition +# into a generated struct member, as well as converting type names +# into substrings of a generated C function name. +# '__a.b_c' -> '__a_b_c', 'x-foo' -> 'x_foo' +# protect=True: 'int' -> 'q_int'; protect=False: 'int' -> 'int' def c_name(name, protect=True): # ANSI X3J11/88-090, 3.1.1 c89_words = set(['auto', 'break', 'case', 'char', 'const', 'continue', @@ -800,13 +809,25 @@ def c_name(name, protect=True): return "q_" + name return name.translate(c_name_trans) +# Map type @name to the C typedef name for the list form. +# +# ['Name'] -> 'NameList', ['x-Foo'] -> 'x_FooList', ['int'] -> 'intList' def c_list_type(name): - return name + 'List' + return type_name(name) + 'List' +# Map type @value to the C typedef form. +# +# Used for converting 'type' from a 'member':'type' qapi definition +# into the alphanumeric portion of the type for a generated C parameter, +# as well as generated C function names. See c_type() for the rest of +# the conversion such as adding '*' on pointer types. +# 'int' -> 'int', '[x-Foo]' -> 'x_FooList', '__a.b_c' -> '__a_b_c' def type_name(value): if type(value) == list: return c_list_type(value[0]) - return value + if value in builtin_types.keys(): + return value + return c_name(value) def add_name(name, info, meta, implicit = False): global all_names @@ -865,6 +886,10 @@ def is_enum(name): eatspace = '\033EATSPACE.' pointer_suffix = ' *' + eatspace +# Map type @name to its C type expression. +# If @is_param, const-qualify the string type. +# +# This function is used for computing the full C type of 'member':'name'. # 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(). @@ -889,7 +914,7 @@ def c_type(value, is_param=False): elif type(value) == list: return c_list_type(value[0]) + pointer_suffix elif is_enum(value): - return value + return c_name(value) elif value == None: return 'void' elif value in events: @@ -897,7 +922,7 @@ def c_type(value, is_param=False): else: # complex type name assert isinstance(value, str) and str != "" - return value + pointer_suffix + return c_name(value) + pointer_suffix def is_c_ptr(value): return c_type(value).endswith(pointer_suffix) -- 2.1.0