[mirror_frr.git] / python / clidef.py

# FRR CLI preprocessor (DEFPY)
#
# Copyright (C) 2017  David Lamparter for NetDEF, Inc.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
# Software Foundation; either version 2 of the License, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
# more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; see the file COPYING; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

import clippy, traceback, sys, os
from collections import OrderedDict
from functools import reduce
from pprint import pprint
from string import Template
from io import StringIO

# the various handlers generate output C code for a particular type of
# CLI token, choosing the most useful output C type.

class RenderHandler(object):
    def __init__(self, token):
        pass
    def combine(self, other):
        if type(self) == type(other):
            return other
        return StringHandler(None)

    deref = ''
    drop_str = False

class StringHandler(RenderHandler):
    argtype = 'const char *'
    decl = Template('const char *$varname = NULL;')
    code = Template('$varname = argv[_i]->arg;')
    drop_str = True

class LongHandler(RenderHandler):
    argtype = 'long'
    decl = Template('long $varname = 0;')
    code = Template('''\
char *_end;
$varname = strtol(argv[_i]->arg, &_end, 10);
_fail = (_end == argv[_i]->arg) || (*_end != '\\0');''')

# A.B.C.D/M (prefix_ipv4) and
# X:X::X:X/M (prefix_ipv6) are "compatible" and can merge into a
# struct prefix:

class PrefixBase(RenderHandler):
    def combine(self, other):
        if type(self) == type(other):
            return other
        if type(other) in [Prefix4Handler, Prefix6Handler, PrefixGenHandler]:
            return PrefixGenHandler(None)
        return StringHandler(None)
    deref = '&'
class Prefix4Handler(PrefixBase):
    argtype = 'const struct prefix_ipv4 *'
    decl = Template('struct prefix_ipv4 $varname = { };')
    code = Template('_fail = !str2prefix_ipv4(argv[_i]->arg, &$varname);')
class Prefix6Handler(PrefixBase):
    argtype = 'const struct prefix_ipv6 *'
    decl = Template('struct prefix_ipv6 $varname = { };')
    code = Template('_fail = !str2prefix_ipv6(argv[_i]->arg, &$varname);')
class PrefixGenHandler(PrefixBase):
    argtype = 'const struct prefix *'
    decl = Template('struct prefix $varname = { };')
    code = Template('_fail = !str2prefix(argv[_i]->arg, &$varname);')

# same for IP addresses.  result is union sockunion.
class IPBase(RenderHandler):
    def combine(self, other):
        if type(self) == type(other):
            return other
        if type(other) in [IP4Handler, IP6Handler, IPGenHandler]:
            return IPGenHandler(None)
        return StringHandler(None)
class IP4Handler(IPBase):
    argtype = 'struct in_addr'
    decl = Template('struct in_addr $varname = { INADDR_ANY };')
    code = Template('_fail = !inet_aton(argv[_i]->arg, &$varname);')
class IP6Handler(IPBase):
    argtype = 'struct in6_addr'
    decl = Template('struct in6_addr $varname = IN6ADDR_ANY_INIT;')
    code = Template('_fail = !inet_pton(AF_INET6, argv[_i]->arg, &$varname);')
class IPGenHandler(IPBase):
    argtype = 'const union sockunion *'
    decl = Template('''union sockunion s__$varname = { .sa.sa_family = AF_UNSPEC }, *$varname = NULL;''')
    code = Template('''\
if (argv[_i]->text[0] == 'X') {
	s__$varname.sa.sa_family = AF_INET6;
	_fail = !inet_pton(AF_INET6, argv[_i]->arg, &s__$varname.sin6.sin6_addr);
	$varname = &s__$varname;
} else {
	s__$varname.sa.sa_family = AF_INET;
	_fail = !inet_aton(argv[_i]->arg, &s__$varname.sin.sin_addr);
	$varname = &s__$varname;
}''')

def mix_handlers(handlers):
    def combine(a, b):
        if a is None:
            return b
        return a.combine(b)
    return reduce(combine, handlers, None)

handlers = {
    'WORD_TKN':         StringHandler,
    'VARIABLE_TKN':     StringHandler,
    'RANGE_TKN':        LongHandler,
    'IPV4_TKN':         IP4Handler,
    'IPV4_PREFIX_TKN':  Prefix4Handler,
    'IPV6_TKN':         IP6Handler,
    'IPV6_PREFIX_TKN':  Prefix6Handler,
}

# core template invoked for each occurence of DEFPY.
templ = Template('''/* $fnname => "$cmddef" */
DEFUN_CMD_FUNC_DECL($fnname)
#define funcdecl_$fnname static int ${fnname}_magic(\\
	const struct cmd_element *self __attribute__ ((unused)),\\
	struct vty *vty __attribute__ ((unused)),\\
	int argc __attribute__ ((unused)),\\
	struct cmd_token *argv[] __attribute__ ((unused))$argdefs)
funcdecl_$fnname;
DEFUN_CMD_FUNC_TEXT($fnname)
{
	int _i;
	unsigned _fail = 0, _failcnt = 0;
$argdecls
	for (_i = 0; _i < argc; _i++) {
		if (!argv[_i]->varname)
			continue;
		_fail = 0;$argblocks
		if (_fail)
			vty_outln (vty, "%% invalid input for %s: %s",
				   argv[_i]->varname, argv[_i]->arg);
		_failcnt += _fail;
	}
	if (_failcnt)
		return CMD_WARNING;
	return ${fnname}_magic(self, vty, argc, argv$arglist);
}

''')

# invoked for each named parameter
argblock = Template('''
		if (!strcmp(argv[_i]->varname, \"$varname\")) {$strblock
			$code
		}''')

def process_file(fn, ofd, dumpfd, all_defun):
    filedata = clippy.parse(fn)

    for entry in filedata['data']:
        if entry['type'] == 'DEFPY' or (all_defun and entry['type'].startswith('DEFUN')):
            cmddef = entry['args'][2]
            for i in cmddef:
                assert i.startswith('"') and i.endswith('"')
            cmddef = ''.join([i[1:-1] for i in cmddef])

            graph = clippy.Graph(cmddef)
            args = OrderedDict()
            for token, depth in clippy.graph_iterate(graph):
                if token.type not in handlers:
                    continue
                if token.varname is None:
                    continue
                arg = args.setdefault(token.varname, [])
                arg.append(handlers[token.type](token))

            #print('-' * 76)
            #pprint(entry)
            #clippy.dump(graph)
            #pprint(args)

            params = { 'cmddef': cmddef, 'fnname': entry['args'][0][0] }
            argdefs = []
            argdecls = []
            arglist = []
            argblocks = []
            doc = []

            def do_add(handler, varname, attr = ''):
                argdefs.append(',\\\n\t%s %s%s' % (handler.argtype, varname, attr))
                argdecls.append('\t%s\n' % (handler.decl.substitute({'varname': varname}).replace('\n', '\n\t')))
                arglist.append(', %s%s' % (handler.deref, varname))
                if attr == '':
                    at = handler.argtype
                    if not at.startswith('const '):
                        at = '. . . ' + at
                    doc.append('\t%-26s %s' % (at, varname))

            for varname in args.keys():
                handler = mix_handlers(args[varname])
                #print(varname, handler)
                if handler is None: continue
                do_add(handler, varname)
                code = handler.code.substitute({'varname': varname}).replace('\n', '\n\t\t\t')
                strblock = ''
                if not handler.drop_str:
                    do_add(StringHandler(None), '%s_str' % (varname), ' __attribute__ ((unused))')
                    strblock = '\n\t\t\t%s_str = argv[_i]->arg;' % (varname)
                argblocks.append(argblock.substitute({'varname': varname, 'strblock': strblock, 'code': code}))

            if dumpfd is not None:
                if len(arglist) > 0:
                    dumpfd.write('"%s":\n%s\n\n' % (cmddef, '\n'.join(doc)))
                else:
                    dumpfd.write('"%s":\n\t---- no magic arguments ----\n\n' % (cmddef))

            params['argdefs'] = ''.join(argdefs)
            params['argdecls'] = ''.join(argdecls)
            params['arglist'] = ''.join(arglist)
            params['argblocks'] = ''.join(argblocks)
            ofd.write(templ.substitute(params))

if __name__ == '__main__':
    import argparse

    argp = argparse.ArgumentParser(description = 'FRR CLI preprocessor in Python')
    argp.add_argument('--all-defun', action = 'store_const', const = True,
            help = 'process DEFUN() statements in addition to DEFPY()')
    argp.add_argument('--show', action = 'store_const', const = True,
            help = 'print out list of arguments and types for each definition')
    argp.add_argument('-o', type = str, metavar = 'OUTFILE',
            help = 'output C file name')
    argp.add_argument('cfile', type = str)
    args = argp.parse_args()

    dumpfd = None
    if args.o is not None:
        ofd = StringIO()
        if args.show:
            dumpfd = sys.stdout
    else:
        ofd = sys.stdout
        if args.show:
            dumpfd = sys.stderr

    process_file(args.cfile, ofd, dumpfd, args.all_defun)

    if args.o is not None:
        clippy.wrdiff(args.o, ofd)
Commit	Line	Data
5578a14d DL	1	# FRR CLI preprocessor (DEFPY)
	2	#
	3	# Copyright (C) 2017 David Lamparter for NetDEF, Inc.
	4	#
	5	# This program is free software; you can redistribute it and/or modify it
	6	# under the terms of the GNU General Public License as published by the Free
	7	# Software Foundation; either version 2 of the License, or (at your option)
	8	# any later version.
	9	#
	10	# This program is distributed in the hope that it will be useful, but WITHOUT
	11	# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	13	# more details.
	14	#
	15	# You should have received a copy of the GNU General Public License along
	16	# with this program; see the file COPYING; if not, write to the Free Software
	17	# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	import clippy, traceback, sys, os
	20	from collections import OrderedDict
	21	from functools import reduce
	22	from pprint import pprint
	23	from string import Template
	24	from io import StringIO
	25
	26	# the various handlers generate output C code for a particular type of
	27	# CLI token, choosing the most useful output C type.
	28
	29	class RenderHandler(object):
	30	def __init__(self, token):
	31	pass
	32	def combine(self, other):
	33	if type(self) == type(other):
	34	return other
	35	return StringHandler(None)
	36
	37	deref = ''
	38	drop_str = False
	39
	40	class StringHandler(RenderHandler):
	41	argtype = 'const char *'
	42	decl = Template('const char *$varname = NULL;')
	43	code = Template('$varname = argv[_i]->arg;')
	44	drop_str = True
	45
	46	class LongHandler(RenderHandler):
	47	argtype = 'long'
	48	decl = Template('long $varname = 0;')
	49	code = Template('''\
	50	char *_end;
	51	$varname = strtol(argv[_i]->arg, &_end, 10);
	52	_fail = (_end == argv[_i]->arg) \|\| (*_end != '\\0');''')
	53
	54	# A.B.C.D/M (prefix_ipv4) and
	55	# X:X::X:X/M (prefix_ipv6) are "compatible" and can merge into a
	56	# struct prefix:
	57
	58	class PrefixBase(RenderHandler):
	59	def combine(self, other):
	60	if type(self) == type(other):
	61	return other
	62	if type(other) in [Prefix4Handler, Prefix6Handler, PrefixGenHandler]:
	63	return PrefixGenHandler(None)
	64	return StringHandler(None)
65	deref = '&'
66	class Prefix4Handler(PrefixBase):
67	argtype = 'const struct prefix_ipv4 *'
68	decl = Template('struct prefix_ipv4 $varname = { };')
69	code = Template('_fail = !str2prefix_ipv4(argv[_i]->arg, &$varname);')
70	class Prefix6Handler(PrefixBase):
71	argtype = 'const struct prefix_ipv6 *'
72	decl = Template('struct prefix_ipv6 $varname = { };')
73	code = Template('_fail = !str2prefix_ipv6(argv[_i]->arg, &$varname);')
74	class PrefixGenHandler(PrefixBase):
75	argtype = 'const struct prefix *'
76	decl = Template('struct prefix $varname = { };')
77	code = Template('_fail = !str2prefix(argv[_i]->arg, &$varname);')
78
79	# same for IP addresses. result is union sockunion.
80	class IPBase(RenderHandler):
81	def combine(self, other):
82	if type(self) == type(other):
83	return other
84	if type(other) in [IP4Handler, IP6Handler, IPGenHandler]:
85	return IPGenHandler(None)
86	return StringHandler(None)
87	class IP4Handler(IPBase):
88	argtype = 'struct in_addr'
89	decl = Template('struct in_addr $varname = { INADDR_ANY };')
90	code = Template('_fail = !inet_aton(argv[_i]->arg, &$varname);')
91	class IP6Handler(IPBase):
92	argtype = 'struct in6_addr'
93	decl = Template('struct in6_addr $varname = IN6ADDR_ANY_INIT;')
94	code = Template('_fail = !inet_pton(AF_INET6, argv[_i]->arg, &$varname);')
95	class IPGenHandler(IPBase):
96	argtype = 'const union sockunion *'
97	decl = Template('''union sockunion s__$varname = { .sa.sa_family = AF_UNSPEC }, *$varname = NULL;''')
98	code = Template('''\
99	if (argv[_i]->text[0] == 'X') {
100	s__$varname.sa.sa_family = AF_INET6;
101	_fail = !inet_pton(AF_INET6, argv[_i]->arg, &s__$varname.sin6.sin6_addr);
102	$varname = &s__$varname;
103	} else {
104	s__$varname.sa.sa_family = AF_INET;
105	_fail = !inet_aton(argv[_i]->arg, &s__$varname.sin.sin_addr);
106	$varname = &s__$varname;
107	}''')
108
109	def mix_handlers(handlers):
110	def combine(a, b):
111	if a is None:
112	return b
113	return a.combine(b)
114	return reduce(combine, handlers, None)
115
116	handlers = {
117	'WORD_TKN': StringHandler,
118	'VARIABLE_TKN': StringHandler,
119	'RANGE_TKN': LongHandler,
120	'IPV4_TKN': IP4Handler,
121	'IPV4_PREFIX_TKN': Prefix4Handler,
122	'IPV6_TKN': IP6Handler,
123	'IPV6_PREFIX_TKN': Prefix6Handler,
124	}
125
126	# core template invoked for each occurence of DEFPY.
127	templ = Template('''/* $fnname => "$cmddef" */
128	DEFUN_CMD_FUNC_DECL($fnname)
129	#define funcdecl_$fnname static int ${fnname}_magic(\\
130	const struct cmd_element *self __attribute__ ((unused)),\\
131	struct vty *vty __attribute__ ((unused)),\\
132	int argc __attribute__ ((unused)),\\
133	struct cmd_token *argv[] __attribute__ ((unused))$argdefs)
134	funcdecl_$fnname;
135	DEFUN_CMD_FUNC_TEXT($fnname)
136	{
137	int _i;
138	unsigned _fail = 0, _failcnt = 0;
139	$argdecls
140	for (_i = 0; _i < argc; _i++) {
141	if (!argv[_i]->varname)
142	continue;
143	_fail = 0;$argblocks
144	if (_fail)
8e25c8ce QY	145	vty_outln (vty, "%% invalid input for %s: %s",
8e25c8ce QY	146	argv[_i]->varname, argv[_i]->arg);
5578a14d DL	147	_failcnt += _fail;
	148	}
	149	if (_failcnt)
	150	return CMD_WARNING;
	151	return ${fnname}_magic(self, vty, argc, argv$arglist);
	152	}
	153
	154	''')
	155
	156	# invoked for each named parameter
	157	argblock = Template('''
	158	if (!strcmp(argv[_i]->varname, \"$varname\")) {$strblock
	159	$code
	160	}''')
	161
	162	def process_file(fn, ofd, dumpfd, all_defun):
	163	filedata = clippy.parse(fn)
	164
	165	for entry in filedata['data']:
	166	if entry['type'] == 'DEFPY' or (all_defun and entry['type'].startswith('DEFUN')):
	167	cmddef = entry['args'][2]
	168	for i in cmddef:
	169	assert i.startswith('"') and i.endswith('"')
	170	cmddef = ''.join([i[1:-1] for i in cmddef])
	171
	172	graph = clippy.Graph(cmddef)
	173	args = OrderedDict()
	174	for token, depth in clippy.graph_iterate(graph):
	175	if token.type not in handlers:
	176	continue
	177	if token.varname is None:
	178	continue
	179	arg = args.setdefault(token.varname, [])
	180	arg.append(handlers[token.type](token))
	181
	182	#print('-' * 76)
	183	#pprint(entry)
	184	#clippy.dump(graph)
	185	#pprint(args)
	186
	187	params = { 'cmddef': cmddef, 'fnname': entry['args'][0][0] }
	188	argdefs = []
	189	argdecls = []
	190	arglist = []
	191	argblocks = []
	192	doc = []
	193
	194	def do_add(handler, varname, attr = ''):
	195	argdefs.append(',\\\n\t%s %s%s' % (handler.argtype, varname, attr))
	196	argdecls.append('\t%s\n' % (handler.decl.substitute({'varname': varname}).replace('\n', '\n\t')))
	197	arglist.append(', %s%s' % (handler.deref, varname))
	198	if attr == '':
	199	at = handler.argtype
	200	if not at.startswith('const '):
	201	at = '. . . ' + at
	202	doc.append('\t%-26s %s' % (at, varname))
	203
	204	for varname in args.keys():
	205	handler = mix_handlers(args[varname])
	206	#print(varname, handler)
	207	if handler is None: continue
	208	do_add(handler, varname)
	209	code = handler.code.substitute({'varname': varname}).replace('\n', '\n\t\t\t')
	210	strblock = ''
211	if not handler.drop_str:
212	do_add(StringHandler(None), '%s_str' % (varname), ' __attribute__ ((unused))')
213	strblock = '\n\t\t\t%s_str = argv[_i]->arg;' % (varname)
214	argblocks.append(argblock.substitute({'varname': varname, 'strblock': strblock, 'code': code}))
215
216	if dumpfd is not None:
217	if len(arglist) > 0:
218	dumpfd.write('"%s":\n%s\n\n' % (cmddef, '\n'.join(doc)))
219	else:
220	dumpfd.write('"%s":\n\t---- no magic arguments ----\n\n' % (cmddef))
221
222	params['argdefs'] = ''.join(argdefs)
223	params['argdecls'] = ''.join(argdecls)
224	params['arglist'] = ''.join(arglist)
225	params['argblocks'] = ''.join(argblocks)
226	ofd.write(templ.substitute(params))
227
228	if __name__ == '__main__':
229	import argparse
230
231	argp = argparse.ArgumentParser(description = 'FRR CLI preprocessor in Python')
232	argp.add_argument('--all-defun', action = 'store_const', const = True,
233	help = 'process DEFUN() statements in addition to DEFPY()')
234	argp.add_argument('--show', action = 'store_const', const = True,
235	help = 'print out list of arguments and types for each definition')
236	argp.add_argument('-o', type = str, metavar = 'OUTFILE',
237	help = 'output C file name')
238	argp.add_argument('cfile', type = str)
239	args = argp.parse_args()
240
241	dumpfd = None
242	if args.o is not None:
243	ofd = StringIO()
244	if args.show:
245	dumpfd = sys.stdout
246	else:
247	ofd = sys.stdout
248	if args.show:
249	dumpfd = sys.stderr
250
251	process_file(args.cfile, ofd, dumpfd, args.all_defun)
252
253	if args.o is not None:
254	clippy.wrdiff(args.o, ofd)