mirror of
https://github.com/raspberrypi/linux.git
synced 2025-12-07 02:19:54 +00:00
scripts/kernel-doc.py: Rename the kernel doc Re class to KernRe
Using just "Re" makes it harder to distinguish from the native "re" class. So, let's rename it. Signed-off-by: Mauro Carvalho Chehab <mchehab+huawei@kernel.org> Signed-off-by: Jonathan Corbet <corbet@lwn.net> Link: https://lore.kernel.org/r/4e095ecd5235a3e811ddcf5bad4cfb92f1da0a4a.1744106242.git.mchehab+huawei@kernel.org
This commit is contained in:
Mauro Carvalho Chehab
committed by
Jonathan Corbet
Jonathan Corbet
parent
16740c29db
commit
04a383ced6
@@ -16,7 +16,7 @@ import argparse
|
||||
import re
|
||||
from pprint import pformat
|
||||
|
||||
from kdoc_re import NestedMatch, Re
|
||||
from kdoc_re import NestedMatch, KernRe
|
||||
|
||||
|
||||
#
|
||||
@@ -29,12 +29,12 @@ from kdoc_re import NestedMatch, Re
|
||||
#
|
||||
|
||||
# Allow whitespace at end of comment start.
|
||||
doc_start = Re(r'^/\*\*\s*$', cache=False)
|
||||
doc_start = KernRe(r'^/\*\*\s*$', cache=False)
|
||||
|
||||
doc_end = Re(r'\*/', cache=False)
|
||||
doc_com = Re(r'\s*\*\s*', cache=False)
|
||||
doc_com_body = Re(r'\s*\* ?', cache=False)
|
||||
doc_decl = doc_com + Re(r'(\w+)', cache=False)
|
||||
doc_end = KernRe(r'\*/', cache=False)
|
||||
doc_com = KernRe(r'\s*\*\s*', cache=False)
|
||||
doc_com_body = KernRe(r'\s*\* ?', cache=False)
|
||||
doc_decl = doc_com + KernRe(r'(\w+)', cache=False)
|
||||
|
||||
# @params and a strictly limited set of supported section names
|
||||
# Specifically:
|
||||
@@ -44,22 +44,22 @@ doc_decl = doc_com + Re(r'(\w+)', cache=False)
|
||||
# while trying to not match literal block starts like "example::"
|
||||
#
|
||||
doc_sect = doc_com + \
|
||||
Re(r'\s*(\@[.\w]+|\@\.\.\.|description|context|returns?|notes?|examples?)\s*:([^:].*)?$',
|
||||
KernRe(r'\s*(\@[.\w]+|\@\.\.\.|description|context|returns?|notes?|examples?)\s*:([^:].*)?$',
|
||||
flags=re.I, cache=False)
|
||||
|
||||
doc_content = doc_com_body + Re(r'(.*)', cache=False)
|
||||
doc_block = doc_com + Re(r'DOC:\s*(.*)?', cache=False)
|
||||
doc_inline_start = Re(r'^\s*/\*\*\s*$', cache=False)
|
||||
doc_inline_sect = Re(r'\s*\*\s*(@\s*[\w][\w\.]*\s*):(.*)', cache=False)
|
||||
doc_inline_end = Re(r'^\s*\*/\s*$', cache=False)
|
||||
doc_inline_oneline = Re(r'^\s*/\*\*\s*(@[\w\s]+):\s*(.*)\s*\*/\s*$', cache=False)
|
||||
attribute = Re(r"__attribute__\s*\(\([a-z0-9,_\*\s\(\)]*\)\)",
|
||||
doc_content = doc_com_body + KernRe(r'(.*)', cache=False)
|
||||
doc_block = doc_com + KernRe(r'DOC:\s*(.*)?', cache=False)
|
||||
doc_inline_start = KernRe(r'^\s*/\*\*\s*$', cache=False)
|
||||
doc_inline_sect = KernRe(r'\s*\*\s*(@\s*[\w][\w\.]*\s*):(.*)', cache=False)
|
||||
doc_inline_end = KernRe(r'^\s*\*/\s*$', cache=False)
|
||||
doc_inline_oneline = KernRe(r'^\s*/\*\*\s*(@[\w\s]+):\s*(.*)\s*\*/\s*$', cache=False)
|
||||
attribute = KernRe(r"__attribute__\s*\(\([a-z0-9,_\*\s\(\)]*\)\)",
|
||||
flags=re.I | re.S, cache=False)
|
||||
|
||||
export_symbol = Re(r'^\s*EXPORT_SYMBOL(_GPL)?\s*\(\s*(\w+)\s*\)\s*', cache=False)
|
||||
export_symbol_ns = Re(r'^\s*EXPORT_SYMBOL_NS(_GPL)?\s*\(\s*(\w+)\s*,\s*"\S+"\)\s*', cache=False)
|
||||
export_symbol = KernRe(r'^\s*EXPORT_SYMBOL(_GPL)?\s*\(\s*(\w+)\s*\)\s*', cache=False)
|
||||
export_symbol_ns = KernRe(r'^\s*EXPORT_SYMBOL_NS(_GPL)?\s*\(\s*(\w+)\s*,\s*"\S+"\)\s*', cache=False)
|
||||
|
||||
type_param = Re(r"\@(\w*((\.\w+)|(->\w+))*(\.\.\.)?)", cache=False)
|
||||
type_param = KernRe(r"\@(\w*((\.\w+)|(->\w+))*(\.\.\.)?)", cache=False)
|
||||
|
||||
|
||||
class KernelDoc:
|
||||
@@ -278,10 +278,10 @@ class KernelDoc:
|
||||
|
||||
self.entry.anon_struct_union = False
|
||||
|
||||
param = Re(r'[\[\)].*').sub('', param, count=1)
|
||||
param = KernRe(r'[\[\)].*').sub('', param, count=1)
|
||||
|
||||
if dtype == "" and param.endswith("..."):
|
||||
if Re(r'\w\.\.\.$').search(param):
|
||||
if KernRe(r'\w\.\.\.$').search(param):
|
||||
# For named variable parameters of the form `x...`,
|
||||
# remove the dots
|
||||
param = param[:-3]
|
||||
@@ -335,7 +335,7 @@ class KernelDoc:
|
||||
# to ignore "[blah" in a parameter string.
|
||||
|
||||
self.entry.parameterlist.append(param)
|
||||
org_arg = Re(r'\s\s+').sub(' ', org_arg)
|
||||
org_arg = KernRe(r'\s\s+').sub(' ', org_arg)
|
||||
self.entry.parametertypes[param] = org_arg
|
||||
|
||||
def save_struct_actual(self, actual):
|
||||
@@ -344,7 +344,7 @@ class KernelDoc:
|
||||
one string item.
|
||||
"""
|
||||
|
||||
actual = Re(r'\s*').sub("", actual, count=1)
|
||||
actual = KernRe(r'\s*').sub("", actual, count=1)
|
||||
|
||||
self.entry.struct_actual += actual + " "
|
||||
|
||||
@@ -355,20 +355,20 @@ class KernelDoc:
|
||||
"""
|
||||
|
||||
# temporarily replace all commas inside function pointer definition
|
||||
arg_expr = Re(r'(\([^\),]+),')
|
||||
arg_expr = KernRe(r'(\([^\),]+),')
|
||||
while arg_expr.search(args):
|
||||
args = arg_expr.sub(r"\1#", args)
|
||||
|
||||
for arg in args.split(splitter):
|
||||
# Strip comments
|
||||
arg = Re(r'\/\*.*\*\/').sub('', arg)
|
||||
arg = KernRe(r'\/\*.*\*\/').sub('', arg)
|
||||
|
||||
# Ignore argument attributes
|
||||
arg = Re(r'\sPOS0?\s').sub(' ', arg)
|
||||
arg = KernRe(r'\sPOS0?\s').sub(' ', arg)
|
||||
|
||||
# Strip leading/trailing spaces
|
||||
arg = arg.strip()
|
||||
arg = Re(r'\s+').sub(' ', arg, count=1)
|
||||
arg = KernRe(r'\s+').sub(' ', arg, count=1)
|
||||
|
||||
if arg.startswith('#'):
|
||||
# Treat preprocessor directive as a typeless variable just to fill
|
||||
@@ -379,63 +379,63 @@ class KernelDoc:
|
||||
self.push_parameter(ln, decl_type, arg, "",
|
||||
"", declaration_name)
|
||||
|
||||
elif Re(r'\(.+\)\s*\(').search(arg):
|
||||
elif KernRe(r'\(.+\)\s*\(').search(arg):
|
||||
# Pointer-to-function
|
||||
|
||||
arg = arg.replace('#', ',')
|
||||
|
||||
r = Re(r'[^\(]+\(\*?\s*([\w\[\]\.]*)\s*\)')
|
||||
r = KernRe(r'[^\(]+\(\*?\s*([\w\[\]\.]*)\s*\)')
|
||||
if r.match(arg):
|
||||
param = r.group(1)
|
||||
else:
|
||||
self.emit_warning(ln, f"Invalid param: {arg}")
|
||||
param = arg
|
||||
|
||||
dtype = Re(r'([^\(]+\(\*?)\s*' + re.escape(param)).sub(r'\1', arg)
|
||||
dtype = KernRe(r'([^\(]+\(\*?)\s*' + re.escape(param)).sub(r'\1', arg)
|
||||
self.save_struct_actual(param)
|
||||
self.push_parameter(ln, decl_type, param, dtype,
|
||||
arg, declaration_name)
|
||||
|
||||
elif Re(r'\(.+\)\s*\[').search(arg):
|
||||
elif KernRe(r'\(.+\)\s*\[').search(arg):
|
||||
# Array-of-pointers
|
||||
|
||||
arg = arg.replace('#', ',')
|
||||
r = Re(r'[^\(]+\(\s*\*\s*([\w\[\]\.]*?)\s*(\s*\[\s*[\w]+\s*\]\s*)*\)')
|
||||
r = KernRe(r'[^\(]+\(\s*\*\s*([\w\[\]\.]*?)\s*(\s*\[\s*[\w]+\s*\]\s*)*\)')
|
||||
if r.match(arg):
|
||||
param = r.group(1)
|
||||
else:
|
||||
self.emit_warning(ln, f"Invalid param: {arg}")
|
||||
param = arg
|
||||
|
||||
dtype = Re(r'([^\(]+\(\*?)\s*' + re.escape(param)).sub(r'\1', arg)
|
||||
dtype = KernRe(r'([^\(]+\(\*?)\s*' + re.escape(param)).sub(r'\1', arg)
|
||||
|
||||
self.save_struct_actual(param)
|
||||
self.push_parameter(ln, decl_type, param, dtype,
|
||||
arg, declaration_name)
|
||||
|
||||
elif arg:
|
||||
arg = Re(r'\s*:\s*').sub(":", arg)
|
||||
arg = Re(r'\s*\[').sub('[', arg)
|
||||
arg = KernRe(r'\s*:\s*').sub(":", arg)
|
||||
arg = KernRe(r'\s*\[').sub('[', arg)
|
||||
|
||||
args = Re(r'\s*,\s*').split(arg)
|
||||
args = KernRe(r'\s*,\s*').split(arg)
|
||||
if args[0] and '*' in args[0]:
|
||||
args[0] = re.sub(r'(\*+)\s*', r' \1', args[0])
|
||||
|
||||
first_arg = []
|
||||
r = Re(r'^(.*\s+)(.*?\[.*\].*)$')
|
||||
r = KernRe(r'^(.*\s+)(.*?\[.*\].*)$')
|
||||
if args[0] and r.match(args[0]):
|
||||
args.pop(0)
|
||||
first_arg.extend(r.group(1))
|
||||
first_arg.append(r.group(2))
|
||||
else:
|
||||
first_arg = Re(r'\s+').split(args.pop(0))
|
||||
first_arg = KernRe(r'\s+').split(args.pop(0))
|
||||
|
||||
args.insert(0, first_arg.pop())
|
||||
dtype = ' '.join(first_arg)
|
||||
|
||||
for param in args:
|
||||
if Re(r'^(\*+)\s*(.*)').match(param):
|
||||
r = Re(r'^(\*+)\s*(.*)')
|
||||
if KernRe(r'^(\*+)\s*(.*)').match(param):
|
||||
r = KernRe(r'^(\*+)\s*(.*)')
|
||||
if not r.match(param):
|
||||
self.emit_warning(ln, f"Invalid param: {param}")
|
||||
continue
|
||||
@@ -447,8 +447,8 @@ class KernelDoc:
|
||||
f"{dtype} {r.group(1)}",
|
||||
arg, declaration_name)
|
||||
|
||||
elif Re(r'(.*?):(\w+)').search(param):
|
||||
r = Re(r'(.*?):(\w+)')
|
||||
elif KernRe(r'(.*?):(\w+)').search(param):
|
||||
r = KernRe(r'(.*?):(\w+)')
|
||||
if not r.match(param):
|
||||
self.emit_warning(ln, f"Invalid param: {param}")
|
||||
continue
|
||||
@@ -477,7 +477,7 @@ class KernelDoc:
|
||||
err = True
|
||||
for px in range(len(prms)): # pylint: disable=C0200
|
||||
prm_clean = prms[px]
|
||||
prm_clean = Re(r'\[.*\]').sub('', prm_clean)
|
||||
prm_clean = KernRe(r'\[.*\]').sub('', prm_clean)
|
||||
prm_clean = attribute.sub('', prm_clean)
|
||||
|
||||
# ignore array size in a parameter string;
|
||||
@@ -486,7 +486,7 @@ class KernelDoc:
|
||||
# and this appears in @prms as "addr[6" since the
|
||||
# parameter list is split at spaces;
|
||||
# hence just ignore "[..." for the sections check;
|
||||
prm_clean = Re(r'\[.*').sub('', prm_clean)
|
||||
prm_clean = KernRe(r'\[.*').sub('', prm_clean)
|
||||
|
||||
if prm_clean == sects[sx]:
|
||||
err = False
|
||||
@@ -512,7 +512,7 @@ class KernelDoc:
|
||||
|
||||
# Ignore an empty return type (It's a macro)
|
||||
# Ignore functions with a "void" return type (but not "void *")
|
||||
if not return_type or Re(r'void\s*\w*\s*$').search(return_type):
|
||||
if not return_type or KernRe(r'void\s*\w*\s*$').search(return_type):
|
||||
return
|
||||
|
||||
if not self.entry.sections.get("Return", None):
|
||||
@@ -535,20 +535,20 @@ class KernelDoc:
|
||||
]
|
||||
|
||||
definition_body = r'\{(.*)\}\s*' + "(?:" + '|'.join(qualifiers) + ")?"
|
||||
struct_members = Re(type_pattern + r'([^\{\};]+)(\{)([^\{\}]*)(\})([^\{\}\;]*)(\;)')
|
||||
struct_members = KernRe(type_pattern + r'([^\{\};]+)(\{)([^\{\}]*)(\})([^\{\}\;]*)(\;)')
|
||||
|
||||
# Extract struct/union definition
|
||||
members = None
|
||||
declaration_name = None
|
||||
decl_type = None
|
||||
|
||||
r = Re(type_pattern + r'\s+(\w+)\s*' + definition_body)
|
||||
r = KernRe(type_pattern + r'\s+(\w+)\s*' + definition_body)
|
||||
if r.search(proto):
|
||||
decl_type = r.group(1)
|
||||
declaration_name = r.group(2)
|
||||
members = r.group(3)
|
||||
else:
|
||||
r = Re(r'typedef\s+' + type_pattern + r'\s*' + definition_body + r'\s*(\w+)\s*;')
|
||||
r = KernRe(r'typedef\s+' + type_pattern + r'\s*' + definition_body + r'\s*(\w+)\s*;')
|
||||
|
||||
if r.search(proto):
|
||||
decl_type = r.group(1)
|
||||
@@ -567,21 +567,21 @@ class KernelDoc:
|
||||
args_pattern = r'([^,)]+)'
|
||||
|
||||
sub_prefixes = [
|
||||
(Re(r'\/\*\s*private:.*?\/\*\s*public:.*?\*\/', re.S | re.I), ''),
|
||||
(Re(r'\/\*\s*private:.*', re.S | re.I), ''),
|
||||
(KernRe(r'\/\*\s*private:.*?\/\*\s*public:.*?\*\/', re.S | re.I), ''),
|
||||
(KernRe(r'\/\*\s*private:.*', re.S | re.I), ''),
|
||||
|
||||
# Strip comments
|
||||
(Re(r'\/\*.*?\*\/', re.S), ''),
|
||||
(KernRe(r'\/\*.*?\*\/', re.S), ''),
|
||||
|
||||
# Strip attributes
|
||||
(attribute, ' '),
|
||||
(Re(r'\s*__aligned\s*\([^;]*\)', re.S), ' '),
|
||||
(Re(r'\s*__counted_by\s*\([^;]*\)', re.S), ' '),
|
||||
(Re(r'\s*__counted_by_(le|be)\s*\([^;]*\)', re.S), ' '),
|
||||
(Re(r'\s*__packed\s*', re.S), ' '),
|
||||
(Re(r'\s*CRYPTO_MINALIGN_ATTR', re.S), ' '),
|
||||
(Re(r'\s*____cacheline_aligned_in_smp', re.S), ' '),
|
||||
(Re(r'\s*____cacheline_aligned', re.S), ' '),
|
||||
(KernRe(r'\s*__aligned\s*\([^;]*\)', re.S), ' '),
|
||||
(KernRe(r'\s*__counted_by\s*\([^;]*\)', re.S), ' '),
|
||||
(KernRe(r'\s*__counted_by_(le|be)\s*\([^;]*\)', re.S), ' '),
|
||||
(KernRe(r'\s*__packed\s*', re.S), ' '),
|
||||
(KernRe(r'\s*CRYPTO_MINALIGN_ATTR', re.S), ' '),
|
||||
(KernRe(r'\s*____cacheline_aligned_in_smp', re.S), ' '),
|
||||
(KernRe(r'\s*____cacheline_aligned', re.S), ' '),
|
||||
|
||||
# Unwrap struct_group macros based on this definition:
|
||||
# __struct_group(TAG, NAME, ATTRS, MEMBERS...)
|
||||
@@ -616,10 +616,10 @@ class KernelDoc:
|
||||
# matched. So, the implementation to drop STRUCT_GROUP() will be
|
||||
# handled in separate.
|
||||
|
||||
(Re(r'\bstruct_group\s*\(([^,]*,)', re.S), r'STRUCT_GROUP('),
|
||||
(Re(r'\bstruct_group_attr\s*\(([^,]*,){2}', re.S), r'STRUCT_GROUP('),
|
||||
(Re(r'\bstruct_group_tagged\s*\(([^,]*),([^,]*),', re.S), r'struct \1 \2; STRUCT_GROUP('),
|
||||
(Re(r'\b__struct_group\s*\(([^,]*,){3}', re.S), r'STRUCT_GROUP('),
|
||||
(KernRe(r'\bstruct_group\s*\(([^,]*,)', re.S), r'STRUCT_GROUP('),
|
||||
(KernRe(r'\bstruct_group_attr\s*\(([^,]*,){2}', re.S), r'STRUCT_GROUP('),
|
||||
(KernRe(r'\bstruct_group_tagged\s*\(([^,]*),([^,]*),', re.S), r'struct \1 \2; STRUCT_GROUP('),
|
||||
(KernRe(r'\b__struct_group\s*\(([^,]*,){3}', re.S), r'STRUCT_GROUP('),
|
||||
|
||||
# Replace macros
|
||||
#
|
||||
@@ -628,15 +628,15 @@ class KernelDoc:
|
||||
# it is better to also move those to the NestedMatch logic,
|
||||
# to ensure that parenthesis will be properly matched.
|
||||
|
||||
(Re(r'__ETHTOOL_DECLARE_LINK_MODE_MASK\s*\(([^\)]+)\)', re.S), r'DECLARE_BITMAP(\1, __ETHTOOL_LINK_MODE_MASK_NBITS)'),
|
||||
(Re(r'DECLARE_PHY_INTERFACE_MASK\s*\(([^\)]+)\)', re.S), r'DECLARE_BITMAP(\1, PHY_INTERFACE_MODE_MAX)'),
|
||||
(Re(r'DECLARE_BITMAP\s*\(' + args_pattern + r',\s*' + args_pattern + r'\)', re.S), r'unsigned long \1[BITS_TO_LONGS(\2)]'),
|
||||
(Re(r'DECLARE_HASHTABLE\s*\(' + args_pattern + r',\s*' + args_pattern + r'\)', re.S), r'unsigned long \1[1 << ((\2) - 1)]'),
|
||||
(Re(r'DECLARE_KFIFO\s*\(' + args_pattern + r',\s*' + args_pattern + r',\s*' + args_pattern + r'\)', re.S), r'\2 *\1'),
|
||||
(Re(r'DECLARE_KFIFO_PTR\s*\(' + args_pattern + r',\s*' + args_pattern + r'\)', re.S), r'\2 *\1'),
|
||||
(Re(r'(?:__)?DECLARE_FLEX_ARRAY\s*\(' + args_pattern + r',\s*' + args_pattern + r'\)', re.S), r'\1 \2[]'),
|
||||
(Re(r'DEFINE_DMA_UNMAP_ADDR\s*\(' + args_pattern + r'\)', re.S), r'dma_addr_t \1'),
|
||||
(Re(r'DEFINE_DMA_UNMAP_LEN\s*\(' + args_pattern + r'\)', re.S), r'__u32 \1'),
|
||||
(KernRe(r'__ETHTOOL_DECLARE_LINK_MODE_MASK\s*\(([^\)]+)\)', re.S), r'DECLARE_BITMAP(\1, __ETHTOOL_LINK_MODE_MASK_NBITS)'),
|
||||
(KernRe(r'DECLARE_PHY_INTERFACE_MASK\s*\(([^\)]+)\)', re.S), r'DECLARE_BITMAP(\1, PHY_INTERFACE_MODE_MAX)'),
|
||||
(KernRe(r'DECLARE_BITMAP\s*\(' + args_pattern + r',\s*' + args_pattern + r'\)', re.S), r'unsigned long \1[BITS_TO_LONGS(\2)]'),
|
||||
(KernRe(r'DECLARE_HASHTABLE\s*\(' + args_pattern + r',\s*' + args_pattern + r'\)', re.S), r'unsigned long \1[1 << ((\2) - 1)]'),
|
||||
(KernRe(r'DECLARE_KFIFO\s*\(' + args_pattern + r',\s*' + args_pattern + r',\s*' + args_pattern + r'\)', re.S), r'\2 *\1'),
|
||||
(KernRe(r'DECLARE_KFIFO_PTR\s*\(' + args_pattern + r',\s*' + args_pattern + r'\)', re.S), r'\2 *\1'),
|
||||
(KernRe(r'(?:__)?DECLARE_FLEX_ARRAY\s*\(' + args_pattern + r',\s*' + args_pattern + r'\)', re.S), r'\1 \2[]'),
|
||||
(KernRe(r'DEFINE_DMA_UNMAP_ADDR\s*\(' + args_pattern + r'\)', re.S), r'dma_addr_t \1'),
|
||||
(KernRe(r'DEFINE_DMA_UNMAP_LEN\s*\(' + args_pattern + r'\)', re.S), r'__u32 \1'),
|
||||
]
|
||||
|
||||
# Regexes here are guaranteed to have the end limiter matching
|
||||
@@ -689,8 +689,8 @@ class KernelDoc:
|
||||
s_id = s_id.strip()
|
||||
|
||||
newmember += f"{maintype} {s_id}; "
|
||||
s_id = Re(r'[:\[].*').sub('', s_id)
|
||||
s_id = Re(r'^\s*\**(\S+)\s*').sub(r'\1', s_id)
|
||||
s_id = KernRe(r'[:\[].*').sub('', s_id)
|
||||
s_id = KernRe(r'^\s*\**(\S+)\s*').sub(r'\1', s_id)
|
||||
|
||||
for arg in content.split(';'):
|
||||
arg = arg.strip()
|
||||
@@ -698,7 +698,7 @@ class KernelDoc:
|
||||
if not arg:
|
||||
continue
|
||||
|
||||
r = Re(r'^([^\(]+\(\*?\s*)([\w\.]*)(\s*\).*)')
|
||||
r = KernRe(r'^([^\(]+\(\*?\s*)([\w\.]*)(\s*\).*)')
|
||||
if r.match(arg):
|
||||
# Pointer-to-function
|
||||
dtype = r.group(1)
|
||||
@@ -717,15 +717,15 @@ class KernelDoc:
|
||||
else:
|
||||
arg = arg.strip()
|
||||
# Handle bitmaps
|
||||
arg = Re(r':\s*\d+\s*').sub('', arg)
|
||||
arg = KernRe(r':\s*\d+\s*').sub('', arg)
|
||||
|
||||
# Handle arrays
|
||||
arg = Re(r'\[.*\]').sub('', arg)
|
||||
arg = KernRe(r'\[.*\]').sub('', arg)
|
||||
|
||||
# Handle multiple IDs
|
||||
arg = Re(r'\s*,\s*').sub(',', arg)
|
||||
arg = KernRe(r'\s*,\s*').sub(',', arg)
|
||||
|
||||
r = Re(r'(.*)\s+([\S+,]+)')
|
||||
r = KernRe(r'(.*)\s+([\S+,]+)')
|
||||
|
||||
if r.search(arg):
|
||||
dtype = r.group(1)
|
||||
@@ -735,7 +735,7 @@ class KernelDoc:
|
||||
continue
|
||||
|
||||
for name in names.split(','):
|
||||
name = Re(r'^\s*\**(\S+)\s*').sub(r'\1', name).strip()
|
||||
name = KernRe(r'^\s*\**(\S+)\s*').sub(r'\1', name).strip()
|
||||
|
||||
if not name:
|
||||
continue
|
||||
@@ -757,12 +757,12 @@ class KernelDoc:
|
||||
self.entry.sectcheck, self.entry.struct_actual)
|
||||
|
||||
# Adjust declaration for better display
|
||||
declaration = Re(r'([\{;])').sub(r'\1\n', declaration)
|
||||
declaration = Re(r'\}\s+;').sub('};', declaration)
|
||||
declaration = KernRe(r'([\{;])').sub(r'\1\n', declaration)
|
||||
declaration = KernRe(r'\}\s+;').sub('};', declaration)
|
||||
|
||||
# Better handle inlined enums
|
||||
while True:
|
||||
r = Re(r'(enum\s+\{[^\}]+),([^\n])')
|
||||
r = KernRe(r'(enum\s+\{[^\}]+),([^\n])')
|
||||
if not r.search(declaration):
|
||||
break
|
||||
|
||||
@@ -774,7 +774,7 @@ class KernelDoc:
|
||||
for clause in def_args:
|
||||
|
||||
clause = clause.strip()
|
||||
clause = Re(r'\s+').sub(' ', clause, count=1)
|
||||
clause = KernRe(r'\s+').sub(' ', clause, count=1)
|
||||
|
||||
if not clause:
|
||||
continue
|
||||
@@ -782,7 +782,7 @@ class KernelDoc:
|
||||
if '}' in clause and level > 1:
|
||||
level -= 1
|
||||
|
||||
if not Re(r'^\s*#').match(clause):
|
||||
if not KernRe(r'^\s*#').match(clause):
|
||||
declaration += "\t" * level
|
||||
|
||||
declaration += "\t" + clause + "\n"
|
||||
@@ -807,24 +807,24 @@ class KernelDoc:
|
||||
"""
|
||||
|
||||
# Ignore members marked private
|
||||
proto = Re(r'\/\*\s*private:.*?\/\*\s*public:.*?\*\/', flags=re.S).sub('', proto)
|
||||
proto = Re(r'\/\*\s*private:.*}', flags=re.S).sub('}', proto)
|
||||
proto = KernRe(r'\/\*\s*private:.*?\/\*\s*public:.*?\*\/', flags=re.S).sub('', proto)
|
||||
proto = KernRe(r'\/\*\s*private:.*}', flags=re.S).sub('}', proto)
|
||||
|
||||
# Strip comments
|
||||
proto = Re(r'\/\*.*?\*\/', flags=re.S).sub('', proto)
|
||||
proto = KernRe(r'\/\*.*?\*\/', flags=re.S).sub('', proto)
|
||||
|
||||
# Strip #define macros inside enums
|
||||
proto = Re(r'#\s*((define|ifdef|if)\s+|endif)[^;]*;', flags=re.S).sub('', proto)
|
||||
proto = KernRe(r'#\s*((define|ifdef|if)\s+|endif)[^;]*;', flags=re.S).sub('', proto)
|
||||
|
||||
members = None
|
||||
declaration_name = None
|
||||
|
||||
r = Re(r'typedef\s+enum\s*\{(.*)\}\s*(\w*)\s*;')
|
||||
r = KernRe(r'typedef\s+enum\s*\{(.*)\}\s*(\w*)\s*;')
|
||||
if r.search(proto):
|
||||
declaration_name = r.group(2)
|
||||
members = r.group(1).rstrip()
|
||||
else:
|
||||
r = Re(r'enum\s+(\w*)\s*\{(.*)\}')
|
||||
r = KernRe(r'enum\s+(\w*)\s*\{(.*)\}')
|
||||
if r.match(proto):
|
||||
declaration_name = r.group(1)
|
||||
members = r.group(2).rstrip()
|
||||
@@ -847,12 +847,12 @@ class KernelDoc:
|
||||
|
||||
member_set = set()
|
||||
|
||||
members = Re(r'\([^;]*?[\)]').sub('', members)
|
||||
members = KernRe(r'\([^;]*?[\)]').sub('', members)
|
||||
|
||||
for arg in members.split(','):
|
||||
if not arg:
|
||||
continue
|
||||
arg = Re(r'^\s*(\w+).*').sub(r'\1', arg)
|
||||
arg = KernRe(r'^\s*(\w+).*').sub(r'\1', arg)
|
||||
self.entry.parameterlist.append(arg)
|
||||
if arg not in self.entry.parameterdescs:
|
||||
self.entry.parameterdescs[arg] = self.undescribed
|
||||
@@ -947,10 +947,10 @@ class KernelDoc:
|
||||
]
|
||||
|
||||
for search, sub, flags in sub_prefixes:
|
||||
prototype = Re(search, flags).sub(sub, prototype)
|
||||
prototype = KernRe(search, flags).sub(sub, prototype)
|
||||
|
||||
# Macros are a special case, as they change the prototype format
|
||||
new_proto = Re(r"^#\s*define\s+").sub("", prototype)
|
||||
new_proto = KernRe(r"^#\s*define\s+").sub("", prototype)
|
||||
if new_proto != prototype:
|
||||
is_define_proto = True
|
||||
prototype = new_proto
|
||||
@@ -987,7 +987,7 @@ class KernelDoc:
|
||||
found = False
|
||||
|
||||
if is_define_proto:
|
||||
r = Re(r'^()(' + name + r')\s+')
|
||||
r = KernRe(r'^()(' + name + r')\s+')
|
||||
|
||||
if r.search(prototype):
|
||||
return_type = ''
|
||||
@@ -1004,7 +1004,7 @@ class KernelDoc:
|
||||
]
|
||||
|
||||
for p in patterns:
|
||||
r = Re(p)
|
||||
r = KernRe(p)
|
||||
|
||||
if r.match(prototype):
|
||||
|
||||
@@ -1071,11 +1071,11 @@ class KernelDoc:
|
||||
typedef_ident = r'\*?\s*(\w\S+)\s*'
|
||||
typedef_args = r'\s*\((.*)\);'
|
||||
|
||||
typedef1 = Re(r'typedef' + typedef_type + r'\(' + typedef_ident + r'\)' + typedef_args)
|
||||
typedef2 = Re(r'typedef' + typedef_type + typedef_ident + typedef_args)
|
||||
typedef1 = KernRe(r'typedef' + typedef_type + r'\(' + typedef_ident + r'\)' + typedef_args)
|
||||
typedef2 = KernRe(r'typedef' + typedef_type + typedef_ident + typedef_args)
|
||||
|
||||
# Strip comments
|
||||
proto = Re(r'/\*.*?\*/', flags=re.S).sub('', proto)
|
||||
proto = KernRe(r'/\*.*?\*/', flags=re.S).sub('', proto)
|
||||
|
||||
# Parse function typedef prototypes
|
||||
for r in [typedef1, typedef2]:
|
||||
@@ -1109,12 +1109,12 @@ class KernelDoc:
|
||||
return
|
||||
|
||||
# Handle nested parentheses or brackets
|
||||
r = Re(r'(\(*.\)\s*|\[*.\]\s*);$')
|
||||
r = KernRe(r'(\(*.\)\s*|\[*.\]\s*);$')
|
||||
while r.search(proto):
|
||||
proto = r.sub('', proto)
|
||||
|
||||
# Parse simple typedefs
|
||||
r = Re(r'typedef.*\s+(\w+)\s*;')
|
||||
r = KernRe(r'typedef.*\s+(\w+)\s*;')
|
||||
if r.match(proto):
|
||||
declaration_name = r.group(1)
|
||||
|
||||
@@ -1195,12 +1195,12 @@ class KernelDoc:
|
||||
decl_end = r"(?:[-:].*)" # end of the name part
|
||||
|
||||
# test for pointer declaration type, foo * bar() - desc
|
||||
r = Re(fr"^{decl_start}([\w\s]+?){parenthesis}?\s*{decl_end}?$")
|
||||
r = KernRe(fr"^{decl_start}([\w\s]+?){parenthesis}?\s*{decl_end}?$")
|
||||
if r.search(line):
|
||||
self.entry.identifier = r.group(1)
|
||||
|
||||
# Test for data declaration
|
||||
r = Re(r"^\s*\*?\s*(struct|union|enum|typedef)\b\s*(\w*)")
|
||||
r = KernRe(r"^\s*\*?\s*(struct|union|enum|typedef)\b\s*(\w*)")
|
||||
if r.search(line):
|
||||
self.entry.decl_type = r.group(1)
|
||||
self.entry.identifier = r.group(2)
|
||||
@@ -1209,15 +1209,15 @@ class KernelDoc:
|
||||
# Look for foo() or static void foo() - description;
|
||||
# or misspelt identifier
|
||||
|
||||
r1 = Re(fr"^{decl_start}{fn_type}(\w+)\s*{parenthesis}\s*{decl_end}?$")
|
||||
r2 = Re(fr"^{decl_start}{fn_type}(\w+[^-:]*){parenthesis}\s*{decl_end}$")
|
||||
r1 = KernRe(fr"^{decl_start}{fn_type}(\w+)\s*{parenthesis}\s*{decl_end}?$")
|
||||
r2 = KernRe(fr"^{decl_start}{fn_type}(\w+[^-:]*){parenthesis}\s*{decl_end}$")
|
||||
|
||||
for r in [r1, r2]:
|
||||
if r.search(line):
|
||||
self.entry.identifier = r.group(1)
|
||||
self.entry.decl_type = "function"
|
||||
|
||||
r = Re(r"define\s+")
|
||||
r = KernRe(r"define\s+")
|
||||
self.entry.identifier = r.sub("", self.entry.identifier)
|
||||
self.entry.is_kernel_comment = True
|
||||
break
|
||||
@@ -1230,12 +1230,12 @@ class KernelDoc:
|
||||
self.entry.section = self.section_default
|
||||
self.entry.new_start_line = ln + 1
|
||||
|
||||
r = Re("[-:](.*)")
|
||||
r = KernRe("[-:](.*)")
|
||||
if r.search(line):
|
||||
# strip leading/trailing/multiple spaces
|
||||
self.entry.descr = r.group(1).strip(" ")
|
||||
|
||||
r = Re(r"\s+")
|
||||
r = KernRe(r"\s+")
|
||||
self.entry.descr = r.sub(" ", self.entry.descr)
|
||||
self.entry.declaration_purpose = self.entry.descr
|
||||
self.state = self.STATE_BODY_MAYBE
|
||||
@@ -1272,7 +1272,7 @@ class KernelDoc:
|
||||
"""
|
||||
|
||||
if self.state == self.STATE_BODY_WITH_BLANK_LINE:
|
||||
r = Re(r"\s*\*\s?\S")
|
||||
r = KernRe(r"\s*\*\s?\S")
|
||||
if r.match(line):
|
||||
self.dump_section()
|
||||
self.entry.section = self.section_default
|
||||
@@ -1318,7 +1318,7 @@ class KernelDoc:
|
||||
self.dump_section()
|
||||
|
||||
# Look for doc_com + <text> + doc_end:
|
||||
r = Re(r'\s*\*\s*[a-zA-Z_0-9:\.]+\*/')
|
||||
r = KernRe(r'\s*\*\s*[a-zA-Z_0-9:\.]+\*/')
|
||||
if r.match(line):
|
||||
self.emit_warning(ln, f"suspicious ending line: {line}")
|
||||
|
||||
@@ -1351,7 +1351,7 @@ class KernelDoc:
|
||||
self.entry.declaration_purpose = self.entry.declaration_purpose.rstrip()
|
||||
self.entry.declaration_purpose += " " + cont
|
||||
|
||||
r = Re(r"\s+")
|
||||
r = KernRe(r"\s+")
|
||||
self.entry.declaration_purpose = r.sub(' ',
|
||||
self.entry.declaration_purpose)
|
||||
|
||||
@@ -1359,7 +1359,7 @@ class KernelDoc:
|
||||
if self.entry.section.startswith('@') or \
|
||||
self.entry.section == self.section_context:
|
||||
if self.entry.leading_space is None:
|
||||
r = Re(r'^(\s+)')
|
||||
r = KernRe(r'^(\s+)')
|
||||
if r.match(cont):
|
||||
self.entry.leading_space = len(r.group(1))
|
||||
else:
|
||||
@@ -1436,13 +1436,13 @@ class KernelDoc:
|
||||
is_void = True
|
||||
|
||||
# Replace SYSCALL_DEFINE with correct return type & function name
|
||||
proto = Re(r'SYSCALL_DEFINE.*\(').sub('long sys_', proto)
|
||||
proto = KernRe(r'SYSCALL_DEFINE.*\(').sub('long sys_', proto)
|
||||
|
||||
r = Re(r'long\s+(sys_.*?),')
|
||||
r = KernRe(r'long\s+(sys_.*?),')
|
||||
if r.search(proto):
|
||||
proto = Re(',').sub('(', proto, count=1)
|
||||
proto = KernRe(',').sub('(', proto, count=1)
|
||||
elif is_void:
|
||||
proto = Re(r'\)').sub('(void)', proto, count=1)
|
||||
proto = KernRe(r'\)').sub('(void)', proto, count=1)
|
||||
|
||||
# Now delete all of the odd-numbered commas in the proto
|
||||
# so that argument types & names don't have a comma between them
|
||||
@@ -1469,22 +1469,22 @@ class KernelDoc:
|
||||
tracepointargs = None
|
||||
|
||||
# Match tracepoint name based on different patterns
|
||||
r = Re(r'TRACE_EVENT\((.*?),')
|
||||
r = KernRe(r'TRACE_EVENT\((.*?),')
|
||||
if r.search(proto):
|
||||
tracepointname = r.group(1)
|
||||
|
||||
r = Re(r'DEFINE_SINGLE_EVENT\((.*?),')
|
||||
r = KernRe(r'DEFINE_SINGLE_EVENT\((.*?),')
|
||||
if r.search(proto):
|
||||
tracepointname = r.group(1)
|
||||
|
||||
r = Re(r'DEFINE_EVENT\((.*?),(.*?),')
|
||||
r = KernRe(r'DEFINE_EVENT\((.*?),(.*?),')
|
||||
if r.search(proto):
|
||||
tracepointname = r.group(2)
|
||||
|
||||
if tracepointname:
|
||||
tracepointname = tracepointname.lstrip()
|
||||
|
||||
r = Re(r'TP_PROTO\((.*?)\)')
|
||||
r = KernRe(r'TP_PROTO\((.*?)\)')
|
||||
if r.search(proto):
|
||||
tracepointargs = r.group(1)
|
||||
|
||||
@@ -1501,43 +1501,43 @@ class KernelDoc:
|
||||
"""Ancillary routine to process a function prototype"""
|
||||
|
||||
# strip C99-style comments to end of line
|
||||
r = Re(r"\/\/.*$", re.S)
|
||||
r = KernRe(r"\/\/.*$", re.S)
|
||||
line = r.sub('', line)
|
||||
|
||||
if Re(r'\s*#\s*define').match(line):
|
||||
if KernRe(r'\s*#\s*define').match(line):
|
||||
self.entry.prototype = line
|
||||
elif line.startswith('#'):
|
||||
# Strip other macros like #ifdef/#ifndef/#endif/...
|
||||
pass
|
||||
else:
|
||||
r = Re(r'([^\{]*)')
|
||||
r = KernRe(r'([^\{]*)')
|
||||
if r.match(line):
|
||||
self.entry.prototype += r.group(1) + " "
|
||||
|
||||
if '{' in line or ';' in line or Re(r'\s*#\s*define').match(line):
|
||||
if '{' in line or ';' in line or KernRe(r'\s*#\s*define').match(line):
|
||||
# strip comments
|
||||
r = Re(r'/\*.*?\*/')
|
||||
r = KernRe(r'/\*.*?\*/')
|
||||
self.entry.prototype = r.sub('', self.entry.prototype)
|
||||
|
||||
# strip newlines/cr's
|
||||
r = Re(r'[\r\n]+')
|
||||
r = KernRe(r'[\r\n]+')
|
||||
self.entry.prototype = r.sub(' ', self.entry.prototype)
|
||||
|
||||
# strip leading spaces
|
||||
r = Re(r'^\s+')
|
||||
r = KernRe(r'^\s+')
|
||||
self.entry.prototype = r.sub('', self.entry.prototype)
|
||||
|
||||
# Handle self.entry.prototypes for function pointers like:
|
||||
# int (*pcs_config)(struct foo)
|
||||
|
||||
r = Re(r'^(\S+\s+)\(\s*\*(\S+)\)')
|
||||
r = KernRe(r'^(\S+\s+)\(\s*\*(\S+)\)')
|
||||
self.entry.prototype = r.sub(r'\1\2', self.entry.prototype)
|
||||
|
||||
if 'SYSCALL_DEFINE' in self.entry.prototype:
|
||||
self.entry.prototype = self.syscall_munge(ln,
|
||||
self.entry.prototype)
|
||||
|
||||
r = Re(r'TRACE_EVENT|DEFINE_EVENT|DEFINE_SINGLE_EVENT')
|
||||
r = KernRe(r'TRACE_EVENT|DEFINE_EVENT|DEFINE_SINGLE_EVENT')
|
||||
if r.search(self.entry.prototype):
|
||||
self.entry.prototype = self.tracepoint_munge(ln,
|
||||
self.entry.prototype)
|
||||
@@ -1549,22 +1549,22 @@ class KernelDoc:
|
||||
"""Ancillary routine to process a type"""
|
||||
|
||||
# Strip newlines/cr's.
|
||||
line = Re(r'[\r\n]+', re.S).sub(' ', line)
|
||||
line = KernRe(r'[\r\n]+', re.S).sub(' ', line)
|
||||
|
||||
# Strip leading spaces
|
||||
line = Re(r'^\s+', re.S).sub('', line)
|
||||
line = KernRe(r'^\s+', re.S).sub('', line)
|
||||
|
||||
# Strip trailing spaces
|
||||
line = Re(r'\s+$', re.S).sub('', line)
|
||||
line = KernRe(r'\s+$', re.S).sub('', line)
|
||||
|
||||
# Strip C99-style comments to the end of the line
|
||||
line = Re(r"\/\/.*$", re.S).sub('', line)
|
||||
line = KernRe(r"\/\/.*$", re.S).sub('', line)
|
||||
|
||||
# To distinguish preprocessor directive from regular declaration later.
|
||||
if line.startswith('#'):
|
||||
line += ";"
|
||||
|
||||
r = Re(r'([^\{\};]*)([\{\};])(.*)')
|
||||
r = KernRe(r'([^\{\};]*)([\{\};])(.*)')
|
||||
while True:
|
||||
if r.search(line):
|
||||
if self.entry.prototype:
|
||||
|
||||
Reference in New Issue
Block a user