# exits when reaches limit of printed lines

out = out if out else sys.stdout

global lines

lines += 1

if lines > lines_limit + 1:

out.write(str(a) + ' ⋮\n')

out.write('\t⋮\n')

sys.exit(1)

# raise(Exception('Reached lines limit'))

# exits when reaches limit of printed lines

out = out if out else sys.stdout

global lines

lines += 1

if lines > lines_limit // 2:

global level_limit

level_limit = 2

global verbose

if verbose:

print(inspect.stack()[1][3], str(

*args).rstrip(), file=sys.stderr, **kwargs)

# log with context function

if not verbose:

return

s = str(*args).rstrip()

frameinfo = getframeinfo(currentframe().f_back)

print("%s:%d %s" % (frameinfo.filename, frameinfo.lineno, stack()[1][3]),

s, file=sys.stderr, **kwargs)

# Extract referrer function from oupput of

# git grep --show-function.

# With quirks for linux kernel

line = re.sub(r'__ro_after_init', '', line)

line = re.sub(r'FNAME\((\w+)\)', r'\1', line)

line = re.sub(r'.*TRACE_EVENT.*', '', line)

file_num = r'(^[^\s]+)=(\d+)=[^,]*'

# file=(*name)

m = re.match(file_num + r'\(\*(\b\w+)\)\s*[\(\[=][^;]*$', line)

if not m:

m = re.match(file_num + r'(\b\w+)\s*[\(\[=][^;]*$', line)

if not m:

m = re.match(file_num + r'struct (\b\w+)', line)

if m:

# unittest of extract_referrer

passed = 0

for a in {

"f=1=good2()",

"f=2=static int fastop(struct x86_emulate_ctxt *ctxt, "

+ "void (*fop)(struct fastop *))",

"f=3=int good(a, bad (*func)(arg))",

"f=4=EXPORT_SYMBOL_GPL(bad);",

"f=5=bad (*good)()",

"f=6=int FNAME(good)(a)",

"f=7=TRACE_EVENT(bad)",

"f:8: a=in bad()",

"f=9=struct good",

}:

r = extract_referrer(a)

#print(a, '->', r)

if 'bad' in a and r and 'bad' in r[2]:

print("ERROR: ", a, '->', r)

elif 'good' in a and not r:

print("ERROR:", a)

else:

passed += 1

# Subfunction for searching referrers with

# git grep --show-function.

# Works slowly.

# Obsoleted by doxygen_xml.

res = list()

r = None

# --threads 1--no-index r'**.\[hc\] **.cpp **.cc **.hh'

for line in popen(r'git grep '

r'--show-function '

r'--line-number '

r'"^\s.*\b%s" '

r'$(git grep --word-regexp --files-with-matches '

r'"%s" )'

r'|| true' % (name, name)):

# Filter out names in comment afer function,

# when comment start from ' *'

# To see the problem try "git grep -p and"

for p in {

# exludes:

r'.*:\s+\* .*%s',

r'.*/\*.*%s',

r'.*//.*%s',

r'.*".*\b%s\b.*"'}:

if re.match(p % (name), line):

r = None

break

if r and r[2] != name and r[2] not in ignore:

res.append(r)

r = None

r = extract_referrer(line)

# r is list of file line func

if verbose and r:

print("%-40s\t%s" % (("%s:%s" % (r[0], r[1])), r[2]))

# Subfunction for searching referrers with cscope.

# Works fast.

# Prefer to use doxygen_xml.

global cscope_warned

if not os.path.isfile('data.cscope'):

if not cscope_warned:

print("Recommended: cscope -Rcbk -fdata.cscope", file=sys.stderr)

cscope_warned = True

return []

res = list()

r = None

for l in popen(r'cscope -fdata.cscope -d -L3 "%s"' % (name)):

log(l)

m = re.match(r'([^ ]*) ([^ ]*) ([^ ]*) (.*)', l)

file, func, line_num, line_str = m.groups()

if func in ignore:

continue

res.append([file, line_num, func])

if not res and len(name) > 3:

log(name)

res = func_referrers_git_grep(name)

log(res)

'''

if not referrer:

if os.path.isfile('data.cscope'):

referrer = func_referrers_cscope

else:

print("Using git grep only, recommended to run: cscope -Rcbk -fdata.cscope",

file=sys.stderr)

referrer = func_referrers_git_grep

if isinstance(referrer, str):

referrer = eval(referrer)

if not printed:

printed = set()

# definition

# cscope -d -L1 "arv_camera_new"

if level > level_limit - 2:

print_limited(level*'\t' + name + ' ⋮')

return ''

if name in printed:

print_limited(level*'\t' + name + ' ^')

return

printed.add(name)

print_limited(level*'\t' + name)

for a in referrer(name):

name = a[2]

'''

# prints referrers tree in compact format of

# dependency of make

# Obsoleted by doxygen_xml.

if not referrer:

if os.path.isfile('data.cscope'):

referrer = func_referrers_cscope

else:

print("Using git grep only, recommended to run: cscope -Rcbk -fdata.cscope",

file=sys.stderr)

referrer = func_referrers_git_grep

if isinstance(referrer, str):

referrer = eval(referrer)

if not printed:

printed = set()

if name in printed:

return

if level > level_limit - 2:

return ''

referrers = [a[2] for a in referrer(name)]

if referrers:

printed.add(name)

print("%s:" % (name), ' '.join(referrers))

for a in referrers:

referrers_dep(a, referrer, printed, level + 1)

else:

pass

# TODO: print terminal

'''

log(node)

if not os.path.isfile('data.cscope'):

print("Please run: cscope -Rcbk -fdata.cscope", file=sys.stderr)

return False

if not printed:

printed = set()

u = 0

if node in usage:

u = int(usage[node])

else:

p = node

p = "%s %u" % (node, u)

if level and (node in ignore or u > 100):

if verbose:

print_limited2((level + 1)*'\t' + '\033[2;30m' + p +

(' ^' if node in printed else '') +

'\033[0m')

ignored.add(node)

log(node)

return

if node in printed:

print_limited2(level*'\t' + p + ' ^')

log('')

return

elif level > level_limit - 2 or (level and u and u > 9):

print_limited2(level*'\t' + p + ' ⋮')

log('')

return ''

else:

print_limited2(level*'\t' + p)

printed.add(node)

if level and node in stop:

return

local_printed = set()

for line in popen('cscope -fdata.cscope -d -L2 "%s"' % (node)):

a = line.split()[1]

if a in local_printed:

continue

local_printed.add(a)

# prints call tree in compact format of dependency of make

# Obsoleted by doxygen_xml.

if not os.path.isfile('data.cscope'):

print("Please run: cscope -fdata.cscope -Rcbk", file=sys.stderr)

return False

if printed is None:

printed = set()

if node in printed:

return

calls = list()

for a in [line.split()[1] for line in

popen('cscope -fdata.cscope -d -L2 "%s"' % (node))]:

if a in ignore:

continue

calls.append(a)

if calls:

if level < level_limit - 1:

printed.add(node)

print("%s:" % (node), ' '.join(list(dict.fromkeys(calls))))

for a in list(dict.fromkeys(calls)):

call_dep(a, printed, level + 1)

else:

pass

# TODO: print terminal

# common subfunction

g = nx.DiGraph(name=name)

# g.graph.update({'node': {'shape': 'none', 'fontsize': 50}})

# g.graph.update({'rankdir': 'LR', 'nodesep': 0, })

'''

rm = set()

min_in_degree = g.number_of_nodes() + 1 if not min_in_degree else min_in_degree

log(g.number_of_edges())

rm = [n for (n, d) in g.out_degree if not d and g.in_degree(n)

< min_in_degree]

g.remove_nodes_from(rm)

print(g.number_of_edges())

# subfunction, used in syscalls

# extracts include files of a symbol

res = []

# log(a)

for a in popen('man -s 2 %s 2> /dev/null |'

' head -n 20 | grep include || true' % (a)):

m = re.match('.*<(.*)>', a)

if m:

res.append(m.group(1))

if not res:

for a in popen('grep -l -r " %s *(" '

'/usr/include --include "*.h" '

'2> /dev/null || true' % (a)):

# log(a)

a = re.sub(r'.*/(bits)', r'\1', a)

a = re.sub(r'.*/(sys)', r'\1', a)

a = re.sub(r'/usr/include/(.*)', r'\1', a)

# log(a)

res.append(a)

res = set(res)

if res and len(res) > 1:

r = set()

for f in res:

# log('grep " %s \+\(" --include "%s" -r /usr/include/'%(sym, f))

# log(os.system(

# 'grep -w "%s" --include "%s" -r /usr/include/'%(sym, f)))

if 0 != os.system(

'grep " %s *(" --include "%s" -r /usr/include/ -q'

% (sym, os.path.basename(f))):

r.add(f)

res = res.difference(r)

log(res)

# Experimental function for exporting syscalls info

# from various sources.

# Used in creation of

# https://en.wikibooks.org/wiki/The_Linux_Kernel/Syscalls

# Ex: srcxray.py "write_dot(syscalls(), 'syscalls.dot')"

sc = my_graph('syscalls')

inc = 'includes.list'

if not os.path.isfile(inc):

os.system('ctags --langmap=c:+.h --c-kinds=+pex -I __THROW '

+ ' -R -u -f- /usr/include/ | cut -f1,2 > '

+ inc)

'''

scd = 'SYSCALL_DEFINE.list'

if not os.path.isfile(scd):

os.system("grep SYSCALL_DEFINE -r --include='*.c' > " + scd)

with open(scd, 'r') as f:

v = set(['sigsuspend', 'llseek', 'sysfs',

'sync_file_range2', 'ustat', 'bdflush'])

for s in f:

if any(x in s.lower() for x in ['compat', 'stub']):

continue

m = re.match(r'(.*?):.*SYSCALL.*\(([\w]+)', s)

if m:

for p in {

'^old',

'^xnew',

r'.*64',

r'.*32$',

r'.*16$',

}:

if re.match(p, m.group(2)):

m = None

break

if m:

syscall = m.group(2)

syscall = re.sub('^new', '', syscall)

path = m.group(1).split('/')

if (m.group(1).startswith('mm/nommu.c')

or m.group(1).startswith('arch/x86/ia32')

or m.group(1).startswith('arch/')

or syscall.startswith('vm86')

and not m.group(1).startswith('arch/x86')):

continue

if syscall in v:

continue

v.add(syscall)

p2 = '/'.join(path[1:])

p2 = m.group(1)

# if log(difflib.get_close_matches(syscall, v) or ''):

# log(syscall)

# log(syscall + ' ' + (includes.get(syscall) or '------'))

# man -s 2 timerfd_settime | head -n 20

if False:

i = includes(syscall)

log(p2 + ' ' + str(i) + ' ' + syscall)

sc.add_edge(i, i+' - '+p2)

sc.add_edge(i+' - '+p2, 'sys_' + syscall)

else:

sc.add_edge(path[0] + '/', p2)

sc.add_edge(p2, 'sys_' + syscall)

# cleanups graph file

# wrapper for remove_nodes_from

log('')

g = to_dg(a)

print(dg.number_of_edges())

dg.remove_nodes_from(ignore)

print(dg.number_of_edges())

if i in ignore:

return True

for e in excludes_re:

if re.match(e, i):

'''

dg = to_dg(dg)

passed = set()

# for i in [_ for _ in dg.predecessors(start)]:

p = nx.DiGraph()

for e in excludes_re:

log(e)

while levels:

# log(levels)

# log(starts)

s2 = starts

starts = set()

for s in s2:

for i in dg.predecessors(s):

if i in passed or exclude(i, excludes_re):

continue

passed.add(i)

starts.add(i)

p.add_edge(i, s)

levels -= 1

'''

tree = nx.DiGraph()

def sub(node):

tree.add_node(node)

for o in dg.successors(node):

if o in ignore or tree.has_edge(node, o) or o in starts:

# print(o)

continue

tree.add_edge(node, o)

sub(o)

printed = set()

if not starts:

starts = {}

for i in [n for (n, d) in dg.in_degree if not d]:

starts[i] = dg.out_degree(i)

starts = [a[0] for a in sorted(

starts.items(), key=lambda k: k[1], reverse=True)]

if len(starts) == 1:

sub(starts[0])

elif len(starts) > 1:

for o in starts:

if o in ignore:

continue

sub(o)

'''

dst = open(dst_fn, 'w') if dst_fn else None

printed = set()

def digraph_print_sub(path='', node=None, level=0):

if node in ignore:

return

if node in printed:

print_limited2(level*'\t' + str(node) + ' ^', dst)

return

outs = {_: dg.out_degree(_) for _ in dg.successors(node)}

if sort:

outs = {a: b for a, b in sorted(

outs.items(), key=lambda k: k[1], reverse=True)}

s = ''

if 'rank' in dg.nodes[node]:

s = str(dg.nodes[node]['rank'])

ranks[dg.nodes[node]['rank']].append(node)

final = node in stop or level > level_limit - 2

if outs:

s += ' ⋮' if final else ''

else:

# s += ' @' + path

pass

print_limited2(level*'\t' + str(node) + s, dst)

printed.add(node)

if final:

return ''

passed = set()

for o in outs.keys():

if o in passed:

continue

passed.add(o)

digraph_print_sub(path + ' ' + str(node), o, level + 1)

if not starts:

starts = {}

for i in [n for (n, d) in dg.in_degree if not d]:

starts[i] = dg.out_degree(i)

starts = [a[0] for a in sorted(

starts.items(), key=lambda k: k[1], reverse=True)]

if len(starts) > 1:

print_limited2(default_root, dst)

for s in starts:

print_limited2('\t' + s + ' ->', dst)

passed = set()

for o in starts:

if o in passed:

continue

passed.add(o)

if o in dg:

digraph_print_sub('', o)

# not yet printed rest:

if lines < lines_limit:

for o in dg.nodes():

if o not in printed:

digraph_print_sub('', o)

if dst_fn:

print(dst_fn)

# prepare Linux source for better cflow parsing results

with open(a, 'rb') as f:

for s in f:

try:

s = s.decode('utf-8')

except UnicodeDecodeError:

s = s.decode('latin1')

if cflow_structs:

# treat structs like functions

s = re.sub(r"^static struct (\w+) = ", r"\1()", s)

s = re.sub(r"^static struct (\w+)\[\] = ", r"\1()", s)

s = re.sub(r"^static const struct (\w+)\[\] = ", r"\1()", s)

s = re.sub(r"^struct (.*) =", r"\1()", s)

s = re.sub(r"^static __initdata int \(\*actions\[\]\)\(void\) = ",

"int actions()", s) # init/initramfs.c

s = re.sub(r"^static ", "", s)

s = re.sub(r"SENSOR_DEVICE_ATTR.*\((\w*),",

r"void sensor_dev_attr_\1()(", s)

s = re.sub(r"COMPAT_SYSCALL_DEFINE[0-9]\((\w*),",

r"compat_sys_\1(", s)

s = re.sub(r"SYSCALL_DEFINE[0-9]\((\w*)", r"sys_\1(", s)

s = re.sub(r"__setup\(.*,(.*)\)", r"void __setup() {\1();}", s)

s = re.sub(r"^(\w*)param\(.*,(.*)\)", r"void \1param() {\2();}", s)

s = re.sub(r"^(\w*)initcall\((.*)\)",

r"void \1initcall() {\2();}", s)

s = re.sub(r"^static ", "", s)

s = re.sub(r"^inline ", "", s)

s = re.sub(r"^const ", "", s)

s = re.sub(r"\b__initdata\b", "", s)

s = re.sub(r"DEFINE_PER_CPU\((.*),(.*)\)", r"\1 \2", s)

s = re.sub(r"^(\w+) {$", r"void \1() {", s)

# for line in sys.stdin:

'''

cflow_param = {

"modifier": "__init __inline__ noinline __initdata __randomize_layout asmlinkage __maybe_unused"

" __visible __init __leaf__ __ref __latent_entropy __init_or_module libmosq_EXPORT",

"wrapper": "__attribute__ __section__ "

"TRACE_EVENT MODULE_AUTHOR MODULE_DESCRIPTION MODULE_LICENSE MODULE_LICENSE MODULE_SOFTDEP "

"INIT_THREAD_INFO "

"BUG READ_ONCE EEXIST MAJOR "

"VM_FAULT_ERROR VM_FAULT_MAJOR VM_FAULT_RETRY VM_PFNMAP VM_READ VM_WRITE "

"FAULT_FLAG_ALLOW_RETRY FAULT_FLAG_KILLABLE "

"VM_BUG_ON_VMA FOLL_TOUCH FOLL_POPULATE FOLL_MLOCK VM_LOCKONFAULT VM_SHARED FOLL_WRITE "

"FOLL_PIN FOLL_NUMA FOLL_GET FOLL_FORCE FOLL_LONGTERM FOLL_FAST_ONLY"

"TASK_SIZE "

"fallthrough EHWPOISON "

"__assume_kmalloc_alignment __malloc "

"__acquires __releases __ATTR",

"type":

"pgd_t p4d_t pud_t pmd_t pte_t vm_flags_t"

# "wrapper": "__setup early_param"

}

if os.path.isfile('include/linux/cache.h'):

for m in popen("ctags -x --c-kinds=d include/linux/cache.h | cut -d' ' -f 1 | sort -u"):

if m in cflow_param['modifier']:

print(m)

else:

cflow_param['modifier'] += ' ' + a

if not a:

a = "$(cat cscope.files)" if os.path.isfile(

'cscope.files') else "*.c *.h *.cpp *.hh "

elif isinstance(a, list):

pass

elif os.path.isdir(a):

a = "$(find {0} -name '*.[ch]' -o -name '*.cpp' -o -name '*.hh')".format(a)

pass

elif os.path.isfile(a):

pass

# "--depth=%d " %(level_limit+1) +

# --debug=1

cflow = (r"cflow -m _ignore_main_get_all_ -v "

# + "-DCONFIG_KALLSYMSZ "

+ "--preprocess='srcxray.py cflow_preprocess' "

+ ''.join([''.join(["--symbol={0}:{1} ".format(w, p)

for w in cflow_param[p].split()])

for p in cflow_param.keys()])

+ " --include=_sxt --brief --level-indent='0=\t' "

+ a)

log(cflow)

'''

cf = my_graph()

stack = list()

nprev = -1

cflow_out = open(cflow_out, 'w') if cflow_out else None

for line in cflow(a):

if cflow_out:

cflow_out.write(line + '\n')

# --print-level

m = re.match(r'^([\t]*)([^(^ ^<]+)', str(line))

if m:

n = len(m.group(1))

id = str(m.group(2))

else:

raise Exception(line)

if n <= nprev:

stack = stack[:n - nprev - 1]

# print(n, id, stack)

if id not in ignore:

if len(stack):

cf.add_edge(stack[-1], id)

stack.append(id)

nprev = n

'''

if not outline_txt:

return import_outline(stdin)

if isinstance(outline_txt, str):

with open(outline_txt, 'r') as f:

return import_outline(f)

if isinstance(outline_txt, io.IOBase):

f = outline_txt

stack = list()

nprev = -1

cf = my_graph()

for line in f:

l = line.replace(8*' ', '\t')

m = re.match(r'^([\t ]*)(.*)', l)

if m:

n = len(m.group(1))

id = str(m.group(2))

else:

raise Exception(line)

if not id:

continue

id = re.sub(r' \^$', '', id)

if n <= nprev:

stack = stack[:n - nprev - 1]

# print(n, id, stack)

if id not in ignore:

if len(stack):

cf.add_edge(stack[-1], id)

stack.append(id)

nprev = n

'''

if not isinstance(dg, nx.DiGraph):

dg = import_outline(dg)

rev = my_graph()

for e in dg.edges:

#print(e[0], e[1])

rev.add_edge(e[1].split(' ')[0], e[0])

'''

# a=sys_clone;srcxray.py "write_dot(rank_couples(reduce_graph(remove_loops(read_dot('$a.dot')))),'$a.dot')"

couples = []

ranked = set()

for n in dg:

if n in ranked:

continue

m = n

while True:

if dg.out_degree(m) == 1:

s = list(dg.successors(m))[0]

if dg.in_degree(s) == 1:

couples.append((m, s))

ranked.update(set((m, s)))

dg.nodes[m]['rank1'] = dg.nodes[m]['rank2'] = dg.nodes[s]['rank1'] = dg.nodes[s]['rank2'] = n

m = s

continue

break

'''

#

# srcxray.py "write_dot(add_rank('reduced.dot'), 'ranked.dot')"

g = to_dg(g)

passed1 = set()

passed2 = set()

rn1 = 1

rn2 = -1

r1 = [n for (n, d) in g.in_degree if not d]

r2 = [n for (n, d) in g.out_degree if not d]

while r1 or r2:

if r1:

nxt = set()

for n in r1:

g.nodes[n]['rank1'] = max(rn1, g.nodes[n].get('rank1', rn1))

for i in [_ for _ in g.successors(n)]:

nxt.add(i)

passed1.add(i)

rn1 += 1

r1 = nxt

if r2:

nxt = set()

for n in r2:

g.nodes[n]['rank2'] = min(rn2, g.nodes[n].get('rank2', rn2))

for i in [_ for _ in g.predecessors(n)]:

nxt.add(i)

passed2.add(i)

rn2 -= 1

r2 = nxt

g.__dict__['max_rank'] = rn1

'''

# Other similar external functions to_agraph agwrite

def rank(g, n):

try:

if g.nodes[n]['rank1'] == g.nodes[n]['rank2']:

return g.nodes[n]['rank1']

if g.nodes[n]['rank1'] < abs(g.nodes[n]['rank2']):

return g.nodes[n]['rank1']

else:

return g.__dict__['max_rank'] + 1 + g.nodes[n]['rank2']

except KeyError:

return None

def esc(s):

# re.escape(n))

return s

if isinstance(g, graphviz.Digraph):

g.save(dot)

print(dot)

return

dot = str(dot)

dot = open(dot, 'w')

dot.write('strict digraph "None" {\n')

dot.write('rankdir=LR\nnodesep=0\n')

# dot.write('ranksep=50\n')

dot.write('node [fontname=Ubuntu,shape=none];\n')

# dot.write('edge [width=10000];\n')

dot.write('edge [width=1];\n')

if isinstance(g, nx.DiGraph):

g.remove_nodes_from(ignore)

ranks = collections.defaultdict(list)

for n in g.nodes():

r = rank(g, n)

if r:

ranks[r].append(n)

if not g.out_degree(n):

continue

dot.write('"%s" -> { ' % esc(n))

dot.write(' '.join(['"%s"' % (esc(str(a)))

for a in g.successors(n)]))

if scaled and r and int(r):

dot.write(' } [penwidth=%d label=%d];\n' % (100/r, r))

else:

dot.write(' } ;\n')

# pred

dot.write('// "%s" <- { ' % esc(n))

dot.write(' '.join(['"%s"' % (esc(str(a)))

for a in g.predecessors(n)]))

dot.write(' } ;\n')

print(ranks.keys())

for r in ranks.keys():

dot.write("{ rank=same %s }\n" %

(' '.join(['"%s"' % (str(a)) for a in ranks[r]])))

for n in g.nodes():

prop = Munch(g._node[n])

if scaled and len(ranks):

prop.fontsize = 500 + 10000 / (len(ranks[rank(g, n)]) + 1)

prop.fontsize = 30 + min(5 * len(g.edges(n)), 50)

# prop.label = n + ' ' + str(rank(g,n))

if prop:

dot.write('"%s" [%s]\n' % (esc(n), ','.join(

['%s="%s"' % (a, str(prop[a])) for a in prop])))

elif not g.number_of_edges():

dot.write('"%s"\n' % (n))

# else:

# dot.write('"%s"\n'%(n))

dot.write('}\n')

dot.close()

# faster custom version of eponymous function from external library

# pydot.graph_from_dot_data parse_dot_data from_pydot

dg = nx.DiGraph()

for a in dot:

a = a.strip()

if '->' in a:

m = re.match('"?([^"]+)"? -> {(.+)}', a)

if m:

dg.add_edges_from([(m.group(1), b.strip('"'))

for b in m.group(2).split() if b != m.group(1)])

else:

m = re.match('"?([^"]+)"? -> "?([^"]*)"?;?', a)

if m:

if m.group(1) != m.group(2):

dg.add_edge(m.group(1), m.group(2))

else:

log(a)

elif re.match(r'.*[=\[\]{}]', a):

continue

else: