cmd_descs_generate.py

Go to the documentation of this file.

#!/usr/bin/env python3
# SPDX-FileCopyrightText: 2020-2021 ret2libc <sirmy15@gmail.com>
# SPDX-License-Identifier: LGPL-3.0-only
 
import argparse
import os
import sys
 
import yaml
from cmd_descs_util import (
    CD_ARG_LAST_TYPES,
    CD_TYPE_ARGV,
    CD_TYPE_ARGV_MODES,
    CD_TYPE_ARGV_STATE,
    CD_TYPE_FAKE,
    CD_TYPE_GROUP,
    CD_TYPE_INNER,
    CD_TYPE_OLDINPUT,
    CD_VALID_TYPES,
    compute_cname,
    get_handler_cname,
)
 
CMDDESCS_C_TEMPLATE = """// SPDX-FileCopyrightText: 2021 RizinOrg <info@rizin.re>
// SPDX-License-Identifier: LGPL-3.0-only
//
// WARNING: This file was auto-generated by cmd_descs_generate.py script. Do not
// modify it manually. Look at cmd_descs.yaml if you want to update commands.
//
 
#include <cmd_descs.h>
 
{helps_declarations}
 
{helps}
RZ_IPI void rzshell_cmddescs_init(RzCore *core) {{
\tRzCmdDesc *root_cd = rz_cmd_get_root(core->rcmd);
\trz_cmd_batch_start(core->rcmd);
{init_code}
\trz_cmd_batch_end(core->rcmd);
}}
"""
 
CMDDESCS_H_TEMPLATE = """// SPDX-FileCopyrightText: 2021 RizinOrg <info@rizin.re>
// SPDX-License-Identifier: LGPL-3.0-only
//
// WARNING: This file was auto-generated by cmd_descs_generate.py script. Do not
// modify it manually. Look at cmd_descs.yaml if you want to update commands.
//
 
#include <rz_cmd.h>
#include <rz_core.h>
#include <rz_util.h>
 
// Command handlers, manually defined somewhere else
{handlers_declarations}
 
// Main function that initialize the entire commands tree
RZ_IPI void rzshell_cmddescs_init(RzCore *core);
"""
 
DESC_HELP_DETAIL_ENTRY_TEMPLATE = (
    """\t{{ .text = {text}, .arg_str = {arg_str}, .comment = {comment} }}"""
)
DESC_HELP_DETAIL_ENTRIES_TEMPLATE = """static const RzCmdDescDetailEntry {cname}[] = {{
{entry}
}};
"""
 
DESC_HELP_DETAIL_TEMPLATE = """\t{{ .name = {name}, .entries = {entries} }}"""
DESC_HELP_DETAILS_TEMPLATE = """static const RzCmdDescDetail {cname}[] = {{
{details}
}};
"""
DECL_DESC_HELP_DETAILS_TEMPLATE = "static const RzCmdDescDetail {cname}[{size}];"
 
DESC_HELP_ARG_CHOICES = "static const char *{cname}[] = {{ {choices} }};\n"
DESC_HELP_ARG_UNION_CHOICES = "\t\t.choices = {choices},\n"
DESC_HELP_ARG_UNION_CHOICES_CB = "\t\t.choices_cb = {choices_cb},\n"
DESC_HELP_ARG_TEMPLATE_FLAGS = "\t\t.flags = {flags},\n"
DESC_HELP_ARG_TEMPLATE_OPTIONAL = "\t\t.optional = {optional},\n"
DESC_HELP_ARG_TEMPLATE_NO_SPACE = "\t\t.no_space = {no_space},\n"
DESC_HELP_ARG_TEMPLATE_DEFAULT_VALUE = "\t\t.default_value = {default_value},\n"
DESC_HELP_ARG_TEMPLATE = """\t{{
\t\t.name = {name},
\t\t.type = {type},
{flags}{optional}{no_space}{default_value}{union}
\t}}"""
DESC_HELP_ARGS_TEMPLATE = """static const RzCmdDescArg {cname}[] = {{
{args}
}};
"""
DECL_DESC_HELP_ARGS_TEMPLATE = "static const RzCmdDescArg {cname}[{size}];"
 
DESC_HELP_TEMPLATE_DESCRIPTION = "\t.description = {description},\n"
DESC_HELP_TEMPLATE_ARGS_STR = "\t.args_str = {args_str},\n"
DESC_HELP_TEMPLATE_USAGE = "\t.usage = {usage},\n"
DESC_HELP_TEMPLATE_SORT_SUBCOMMANDS = "\t.sort_subcommands = {sort_subcommands},\n"
DESC_HELP_TEMPLATE_OPTIONS = "\t.options = {options},\n"
DESC_HELP_TEMPLATE_DETAILS = "\t.details = {details},\n"
DESC_HELP_TEMPLATE_DETAILS_CB = "\t.details_cb = {details_cb},\n"
DESC_HELP_TEMPLATE_ARGS = "\t.args = {args},\n"
DESC_HELP_TEMPLATE = """static const RzCmdDescHelp {cname} = {{
\t.summary = {summary},
{description}{args_str}{usage}{options}{details}{details_cb}{args}{sort_subcommands}}};
"""
 
DEFINE_OLDINPUT_TEMPLATE = """
\tRzCmdDesc *{cname}_cd = rz_cmd_desc_oldinput_new(core->rcmd, {parent_cname}_cd, {name}, {handler_cname}, &{help_cname});
\trz_warn_if_fail({cname}_cd);"""
DEFINE_ARGV_TEMPLATE = """
\tRzCmdDesc *{cname}_cd = rz_cmd_desc_argv_new(core->rcmd, {parent_cname}_cd, {name}, {handler_cname}, &{help_cname});
\trz_warn_if_fail({cname}_cd);"""
DEFINE_ARGV_MODES_TEMPLATE = """
\tRzCmdDesc *{cname}_cd = rz_cmd_desc_argv_modes_new(core->rcmd, {parent_cname}_cd, {name}, {modes}, {handler_cname}, &{help_cname});
\trz_warn_if_fail({cname}_cd);"""
DEFINE_ARGV_STATE_TEMPLATE = """
\tRzCmdDesc *{cname}_cd = rz_cmd_desc_argv_state_new(core->rcmd, {parent_cname}_cd, {name}, {modes}, {handler_cname}, &{help_cname});
\trz_warn_if_fail({cname}_cd);"""
DEFINE_GROUP_TEMPLATE = """
\tRzCmdDesc *{cname}_cd = rz_cmd_desc_group_new(core->rcmd, {parent_cname}_cd, {name}, {handler_cname}, {help_cname_ref}, &{group_help_cname});
\trz_warn_if_fail({cname}_cd);"""
DEFINE_GROUP_MODES_TEMPLATE = """
\tRzCmdDesc *{cname}_cd = rz_cmd_desc_group_modes_new(core->rcmd, {parent_cname}_cd, {name}, {modes}, {handler_cname}, {help_cname_ref}, &{group_help_cname});
\trz_warn_if_fail({cname}_cd);"""
DEFINE_GROUP_STATE_TEMPLATE = """
\tRzCmdDesc *{cname}_cd = rz_cmd_desc_group_state_new(core->rcmd, {parent_cname}_cd, {name}, {modes}, {handler_cname}, {help_cname_ref}, &{group_help_cname});
\trz_warn_if_fail({cname}_cd);"""
DEFINE_INNER_TEMPLATE = """
\tRzCmdDesc *{cname}_cd = rz_cmd_desc_inner_new(core->rcmd, {parent_cname}_cd, {name}, &{help_cname});
\trz_warn_if_fail({cname}_cd);"""
DEFINE_FAKE_TEMPLATE = """
\tRzCmdDesc *{cname}_cd = rz_cmd_desc_fake_new(core->rcmd, {parent_cname}_cd, {name}, &{help_cname});
\trz_warn_if_fail({cname}_cd);"""
 
SET_DEFAULT_MODE_TEMPLATE = """
\trz_cmd_desc_set_default_mode({cname}_cd, {default_mode});"""
 
 
def _escape(s):
    return s.replace("\\", "\\\\").replace('"', '\\"')
 
 
def strornull(s):
    return '"' + _escape(s) + '"' if s is not None else "NULL"
 
 
def strip(s):
    return s.strip("\n") if s is not None else None
 
 
class Arg:
    def __init__(self, cd, c):
        if "name" not in c or "type" not in c:
            print("Argument of %s should have `name`/`type` fields" % (cd.name,))
            sys.exit(1)
 
        self.cdcd = cd
        # RzCmdDescArg fields
        self.namename = c.pop("name")
        self.flagsflags = c.pop("flags", None)
        self.optionaloptional = c.pop("optional", None)
        self.no_spaceno_space = c.pop("no_space", None)
        self.typetype = c.pop("type")
        self.default_valuedefault_value = (
            str(c.pop("default_value")) if "default_value" in c else None
        )
        self.choiceschoices = c.pop("choices", None)
        self.choices_cbchoices_cb = c.pop("choices_cb", None)
        if c.keys():
            print(
                "Argument %s for command %s has unrecognized properties: %s."
                % (self.namename, self.cdcd.name, c.keys())
            )
            sys.exit(1)
 
        if self.default_valuedefault_value is not None and self.optionaloptional is not None:
            print(
                "Argument %s for command %s has both optional and default_value."
                % (self.namename, self.cdcd.name)
            )
            sys.exit(1)
 
    def _get_choices_cname(self):
        if self.typetype == "RZ_CMD_ARG_TYPE_CHOICES":
            return self.cdcd.cname + "_" + compute_cname(self.namename) + "_choices"
 
        raise Exception("_get_choices_cname should be called on ARG_TYPE_CHOICES only")
 
    def _get_union(self):
        if self.typetype == "RZ_CMD_ARG_TYPE_CHOICES":
            if self.choices_cbchoices_cb is None:
                return DESC_HELP_ARG_UNION_CHOICES.format(
                    choices=self._get_choices_cname_get_choices_cname()
                )
            return DESC_HELP_ARG_UNION_CHOICES_CB.format(choices_cb=self.choices_cbchoices_cb)
 
        return ""
 
    def __str__(self):
        flags = (
            DESC_HELP_ARG_TEMPLATE_FLAGS.format(flags=self.flagsflags)
            if self.flagsflags is not None and self.flagsflags != ""
            else ""
        )
        optional = (
            DESC_HELP_ARG_TEMPLATE_OPTIONAL.format(
                optional="true" if self.optionaloptional else "false"
            )
            if self.optionaloptional is not None
            else ""
        )
        no_space = (
            DESC_HELP_ARG_TEMPLATE_NO_SPACE.format(
                no_space="true" if self.no_spaceno_space else "false"
            )
            if self.no_spaceno_space is not None
            else ""
        )
        default_value = (
            DESC_HELP_ARG_TEMPLATE_DEFAULT_VALUE.format(
                default_value=strornull(self.default_valuedefault_value)
            )
            if self.default_valuedefault_value is not None
            else ""
        )
        return DESC_HELP_ARG_TEMPLATE.format(
            name=strornull(self.namename),
            type=self.typetype,
            flags=flags,
            optional=optional,
            no_space=no_space,
            default_value=default_value,
            union=self._get_union_get_union(),
        )
 
    def get_cstructure(self):
        if self.typetype == "RZ_CMD_ARG_TYPE_CHOICES" and self.choices_cbchoices_cb is None:
            return DESC_HELP_ARG_CHOICES.format(
                cname=self._get_choices_cname_get_choices_cname(),
                choices=", ".join(
                    [
                        '"%s"' % (x,) if x != "NULL" else x
                        for x in self.choiceschoices + ["NULL"]
                    ]
                ),
            )
        return ""
 
    def decl(self):
        if self.typetype == "RZ_CMD_ARG_TYPE_CHOICES" and self.choices_cbchoices_cb is not None:
            return "RZ_IPI char **%s(RzCore *core);" % (self.choices_cbchoices_cb,)
        return None
 
 
def format_detail_entry(c):
    if "text" not in c or "comment" not in c:
        print("No `text`/`comment` fields for DetailEntry %s" % (c,))
        sys.exit(1)
 
    text = strip(c["text"])
    comment = strip(c["comment"])
    arg_str = strip(c.get("arg_str"))
 
    return DESC_HELP_DETAIL_ENTRY_TEMPLATE.format(
        text=strornull(text),
        arg_str=strornull(arg_str),
        comment=strornull(comment),
    )
 
 
class Detail:
    def __init__(self, cd, c):
        if "name" not in c or "entries" not in c:
            print("No `name`/`entries` fields for Detail %s" % (c,))
            sys.exit(1)
 
        self.cdcd = cd
        # RzCmdDescDetail fields
        self.namename = strip(c.pop("name"))
        self.entriesentries = [format_detail_entry(x) for x in c.pop("entries")]
        if c.keys():
            print(
                "Detail %s for command %s has unrecognized properties: %s."
                % (self.namename, self.cdcd.name, c.keys())
            )
            sys.exit(1)
 
    def get_detail_entries_cname(self):
        return self.cdcd.cname + "_" + compute_cname(self.namename) + "_detail_entries"
 
    def __str__(self):
        return DESC_HELP_DETAIL_TEMPLATE.format(
            name=strornull(self.namename),
            entries=self.get_detail_entries_cnameget_detail_entries_cname(),
        )
 
    def get_cstructure(self):
        return DESC_HELP_DETAIL_ENTRIES_TEMPLATE.format(
            cname=self.get_detail_entries_cnameget_detail_entries_cname(),
            entry=",\n".join([str(e) for e in self.entriesentries] + ["\t{ 0 },"]),
        )
 
 
class CmdDesc:
    c_cds = {}
    c_handlers = {}
    c_args = {}
    c_details = {}
 
    def _process_details(self, c):
        if "details" in c and isinstance(c["details"], list):
            self.detailsdetails = [Detail(self, x) for x in c.pop("details", [])]
        elif "details" in c and isinstance(c["details"], str):
            self.details_aliasdetails_alias = c.pop("details")
        if "details_cb" in c and isinstance(c["details_cb"], str):
            self.details_cbdetails_cb = c.pop("details_cb")
 
    def _process_args(self, c):
        if "args" in c and isinstance(c["args"], list):
            self.argsargs = [Arg(self, x) for x in c.pop("args", [])]
            if (
                self.argsargs
                and self.argsargs[-1].type in CD_ARG_LAST_TYPES
                and self.argsargs[-1].flags is None
            ):
                self.argsargs[-1].flags = "RZ_CMD_ARG_FLAG_LAST"
        elif "args" in c and isinstance(c["args"], str):
            self.args_aliasargs_alias = c.pop("args")
 
    def _set_type(self, c):
        if "type" in c:
            self.typetype = c.pop("type")
        elif c.get("subcommands"):
            self.typetype = CD_TYPE_GROUP
        elif self.modesmodes:
            self.typetype = CD_TYPE_ARGV_MODES
        else:
            self.typetype = CD_TYPE_ARGV
 
    def _set_subcommands(self, c, yamls):
        if "subcommands" in c and isinstance(c["subcommands"], list):
            # The list of subcommands is embedded in the current file
            self.subcommandssubcommands = [
                CmdDesc(yamls, x, self, i)
                for i, x in enumerate(c.pop("subcommands", []))
            ]
        elif "subcommands" in c and isinstance(c["subcommands"], str):
            # The list of subcommands is in another file
            subcommands_name = c.pop("subcommands")
            if subcommands_name not in yamls:
                print(
                    "Command %s referenced another YAML file (%s) that is not passed as arg to cmd_descs_generate.py."
                    % (self.namename, subcommands_name)
                )
                sys.exit(1)
 
            external_c = yamls[subcommands_name]
            self.subcommandssubcommands = [
                CmdDesc(yamls, x, self, i) for i, x in enumerate(external_c)
            ]
 
        # handle the exec_cd, which is a cd that has the same name as its parent
        if (
            self.subcommandssubcommands
            and self.subcommandssubcommands[0].name == self.namename
            and self.subcommandssubcommands[0].type not in [CD_TYPE_INNER, CD_TYPE_FAKE]
        ):
            self.exec_cdexec_cd = self.subcommandssubcommands[0]
 
    def __init__(self, yamls, c, parent=None, pos=0):
        self.pospos = pos
 
        if not c:
            # used only for root node
            self.namename = ""
            self.cnamecname = "root"
            self.summarysummary = ""
            self.typetype = CD_TYPE_GROUP
            return
 
        if not c.get("name") or not c.get("summary"):
            print("No `name`/`summary` fields in", c)
            sys.exit(1)
 
        # RzCmdDesc fields
        self.namename = c.pop("name")
        self.cnamecname = c.pop("cname", None) or compute_cname(self.namename)
        self.typetype = None
        self.parentparent = parent
        self.subcommandssubcommands = None
        self.exec_cdexec_cd = None
        self.modesmodes = c.pop("modes", None)
        self.handlerhandler = c.pop("handler", None)
        self.default_modedefault_mode = c.pop("default_mode", None)
        # RzCmdDescHelp fields
        self.summarysummary = strip(c.pop("summary"))
        self.descriptiondescription = strip(c.pop("description", None))
        self.args_strargs_str = strip(c.pop("args_str", None))
        self.usageusage = strip(c.pop("usage", None))
        self.optionsoptions = strip(c.pop("options", None))
        self.sort_subcommandssort_subcommands = c.pop("sort_subcommands", None)
 
        self.detailsdetails = None
        self.details_aliasdetails_alias = None
        self.details_cbdetails_cb = None
        self._process_details_process_details(c)
 
        self.argsargs = None
        self.args_aliasargs_alias = None
        self._process_args_process_args(c)
 
        # determine type before parsing subcommands, so children can check type of parent
        self._set_type_set_type(c)
 
        self._set_subcommands_set_subcommands(c, yamls)
 
        self._validate_validate(c)
        CmdDesc.c_cds[self.cnamecname] = self
        if self.get_handler_cnameget_handler_cname():
            CmdDesc.c_handlers[self.get_handler_cnameget_handler_cname()] = self
        if self.argsargs:
            CmdDesc.c_args[CmdDesc.get_arg_cname(self)] = self
        if self.detailsdetails:
            CmdDesc.c_details[CmdDesc.get_detail_cname(self)] = self
 
    def _validate(self, c):
        if c.keys():
            print("Command %s has unrecognized properties: %s." % (self.namename, c.keys()))
            sys.exit(1)
 
        if self.typetype not in CD_VALID_TYPES:
            print("Command %s does not have a valid type." % (self.namename,))
            sys.exit(1)
 
        if (
            self.typetype
            in [CD_TYPE_ARGV, CD_TYPE_ARGV_MODES, CD_TYPE_ARGV_STATE, CD_TYPE_OLDINPUT]
            and not self.cnamecname
        ):
            print("Command %s does not have cname field" % (self.namename,))
            sys.exit(1)
 
        if (
            self.parentparent
            and self.parentparent.name == self.namename
            and self.pospos != 0
            and self.typetype not in [CD_TYPE_INNER, CD_TYPE_FAKE]
        ):
            print(
                "If a command has the same name as its parent, it can only be the first child. See parent of Command %s"
                % (self.cnamecname,)
            )
            sys.exit(1)
 
        if self.parentparent and self.parentparent.type not in [
            CD_TYPE_GROUP,
            CD_TYPE_INNER,
            CD_TYPE_OLDINPUT,
        ]:
            print("The parent of %s is of the wrong type" % (self.cnamecname,))
            sys.exit(1)
 
        if self.cnamecname in CmdDesc.c_cds:
            print("Another command already has the same cname as %s" % (self.cnamecname,))
            sys.exit(1)
 
        if (
            self.typetype in [CD_TYPE_ARGV, CD_TYPE_ARGV_MODES, CD_TYPE_ARGV_STATE]
            and self.argsargs is None
            and self.args_aliasargs_alias is None
        ):
            print("Specify arguments for command %s" % (self.namename,))
            sys.exit(1)
 
    def get_handler_cname(self):
        if self.typetype not in [
            CD_TYPE_OLDINPUT,
            CD_TYPE_ARGV,
            CD_TYPE_ARGV_MODES,
            CD_TYPE_ARGV_STATE,
        ]:
            return None
        return get_handler_cname(self.typetype, self.handlerhandler, self.cnamecname)
 
    @classmethod
    def get_arg_cname(cls, cd):
        return cd.cname + "_args"
 
    @classmethod
    def get_detail_cname(cls, cd):
        return cd.cname + "_details"
 
    def get_help_cname(self):
        return self.cnamecname + "_help"
 
    def __str__(self):
        out = ""
        details_cname = None
        args_cname = None
 
        if self.detailsdetails is not None:
            out += "\n".join([d.get_cstructure() for d in self.detailsdetails])
            out += DESC_HELP_DETAILS_TEMPLATE.format(
                cname=CmdDesc.get_detail_cname(self),
                details=",\n".join([str(d) for d in self.detailsdetails] + ["\t{ 0 },"]),
            )
            details_cname = CmdDesc.get_detail_cname(self)
        elif self.details_aliasdetails_alias is not None:
            details_cname = self.details_aliasdetails_alias + "_details"
 
        if self.argsargs is not None:
            out += "\n".join(
                [a.get_cstructure() for a in self.argsargs if a.get_cstructure() != ""]
            )
            out += DESC_HELP_ARGS_TEMPLATE.format(
                cname=CmdDesc.get_arg_cname(self),
                args=",\n".join([str(a) for a in self.argsargs] + ["\t{ 0 },"]),
            )
            args_cname = CmdDesc.get_arg_cname(self)
        elif self.args_aliasargs_alias is not None:
            args_cname = self.args_aliasargs_alias + "_args"
 
        description = (
            DESC_HELP_TEMPLATE_DESCRIPTION.format(
                description=strornull(self.descriptiondescription)
            )
            if self.descriptiondescription is not None
            else ""
        )
        args_str = (
            DESC_HELP_TEMPLATE_ARGS_STR.format(args_str=strornull(self.args_strargs_str))
            if self.args_strargs_str is not None
            else ""
        )
        usage = (
            DESC_HELP_TEMPLATE_USAGE.format(usage=strornull(self.usageusage))
            if self.usageusage is not None
            else ""
        )
        sort_subcommands = (
            DESC_HELP_TEMPLATE_SORT_SUBCOMMANDS.format(
                sort_subcommands="true" if self.sort_subcommandssort_subcommands else "false"
            )
            if self.sort_subcommandssort_subcommands is not None
            else ""
        )
        options = (
            DESC_HELP_TEMPLATE_OPTIONS.format(options=strornull(self.optionsoptions))
            if self.optionsoptions is not None
            else ""
        )
        details = (
            DESC_HELP_TEMPLATE_DETAILS.format(details=details_cname)
            if details_cname is not None
            else ""
        )
        details_cb = (
            DESC_HELP_TEMPLATE_DETAILS_CB.format(details_cb=self.details_cbdetails_cb)
            if self.details_cbdetails_cb is not None
            else ""
        )
        arguments = (
            DESC_HELP_TEMPLATE_ARGS.format(args=args_cname)
            if args_cname is not None
            else ""
        )
        out += DESC_HELP_TEMPLATE.format(
            cname=self.get_help_cnameget_help_cname(),
            summary=strornull(self.summarysummary),
            description=description,
            args_str=args_str,
            usage=usage,
            options=options,
            details=details,
            details_cb=details_cb,
            args=arguments,
            sort_subcommands=sort_subcommands,
        )
 
        if self.subcommandssubcommands:
            out += "\n".join([str(child) for child in self.subcommandssubcommands])
        return out
 
    def str_tab(self, tab=0):
        spaces = " " * tab
        out = ""
        out += spaces + "Name: %s\n" % (self.namename,)
        out += spaces + "CName: %s\n" % (self.cnamecname,)
        out += spaces + "Summary: %s\n" % (self.summarysummary,)
        if self.descriptiondescription:
            out += spaces + "Description: %s\n" % (self.descriptiondescription,)
        if self.subcommandssubcommands:
            out += spaces + "Subcommands:\n"
            for c in self.subcommandssubcommands:
                out += c.str_tab(tab + 4)
                out += "\n"
 
        return out
 
    def __repr__(self):
        return self.str_tabstr_tab()
 
 
def createcd_typegroup(cd):
    if cd.exec_cd and cd.exec_cd.type == CD_TYPE_ARGV_MODES:
        formatted_string = DEFINE_GROUP_MODES_TEMPLATE.format(
            cname=cd.cname,
            parent_cname=cd.parent.cname,
            name=strornull(cd.name),
            modes=" | ".join(cd.exec_cd.modes),
            handler_cname=cd.exec_cd.get_handler_cname(),
            help_cname_ref="&" + cd.exec_cd.get_help_cname(),
            group_help_cname=cd.get_help_cname(),
        )
        if cd.exec_cd.default_mode is not None:
            formatted_string += SET_DEFAULT_MODE_TEMPLATE.format(
                cname=cd.cname,
                default_mode=cd.exec_cd.default_mode,
            )
        formatted_string += "\n".join(
            [createcd(child) for child in cd.subcommands[1:] or []]
        )
    elif cd.exec_cd and cd.exec_cd.type == CD_TYPE_ARGV_STATE:
        formatted_string = DEFINE_GROUP_STATE_TEMPLATE.format(
            cname=cd.cname,
            parent_cname=cd.parent.cname,
            name=strornull(cd.name),
            modes=" | ".join(cd.exec_cd.modes),
            handler_cname=cd.exec_cd.get_handler_cname(),
            help_cname_ref="&" + cd.exec_cd.get_help_cname(),
            group_help_cname=cd.get_help_cname(),
        )
        if cd.exec_cd.default_mode is not None:
            formatted_string += SET_DEFAULT_MODE_TEMPLATE.format(
                cname=cd.cname,
                default_mode=cd.exec_cd.default_mode,
            )
        formatted_string += "\n".join(
            [createcd(child) for child in cd.subcommands[1:] or []]
        )
    else:
        formatted_string = DEFINE_GROUP_TEMPLATE.format(
            cname=cd.cname,
            parent_cname=cd.parent.cname,
            name=strornull(cd.name),
            handler_cname=(cd.exec_cd and cd.exec_cd.get_handler_cname()) or "NULL",
            help_cname_ref=(cd.exec_cd and "&" + cd.exec_cd.get_help_cname()) or "NULL",
            group_help_cname=cd.get_help_cname(),
        )
        subcommands = (
            cd.exec_cd and cd.subcommands and cd.subcommands[1:]
        ) or cd.subcommands
        formatted_string += "\n".join([createcd(child) for child in subcommands or []])
 
    return formatted_string
 
 
def createcd(cd):
    formatted_string = None
 
    if cd.type == CD_TYPE_ARGV:
        formatted_string = DEFINE_ARGV_TEMPLATE.format(
            cname=cd.cname,
            parent_cname=cd.parent.cname,
            name=strornull(cd.name),
            handler_cname=cd.get_handler_cname(),
            help_cname=cd.get_help_cname(),
        )
    elif cd.type == CD_TYPE_ARGV_MODES:
        formatted_string = DEFINE_ARGV_MODES_TEMPLATE.format(
            cname=cd.cname,
            parent_cname=cd.parent.cname,
            name=strornull(cd.name),
            modes=" | ".join(cd.modes),
            handler_cname=cd.get_handler_cname(),
            help_cname=cd.get_help_cname(),
        )
        if cd.default_mode is not None:
            formatted_string += SET_DEFAULT_MODE_TEMPLATE.format(
                cname=cd.cname,
                default_mode=cd.default_mode,
            )
    elif cd.type == CD_TYPE_ARGV_STATE:
        formatted_string = DEFINE_ARGV_STATE_TEMPLATE.format(
            cname=cd.cname,
            parent_cname=cd.parent.cname,
            name=strornull(cd.name),
            modes=" | ".join(cd.modes),
            handler_cname=cd.get_handler_cname(),
            help_cname=cd.get_help_cname(),
        )
        if cd.default_mode is not None:
            formatted_string += SET_DEFAULT_MODE_TEMPLATE.format(
                cname=cd.cname,
                default_mode=cd.default_mode,
            )
    elif cd.type == CD_TYPE_FAKE:
        formatted_string = DEFINE_FAKE_TEMPLATE.format(
            cname=cd.cname,
            parent_cname=cd.parent.cname,
            name=strornull(cd.name),
            help_cname=cd.get_help_cname(),
        )
    elif cd.type == CD_TYPE_INNER:
        formatted_string = DEFINE_INNER_TEMPLATE.format(
            cname=cd.cname,
            parent_cname=cd.parent.cname,
            name=strornull(cd.name),
            help_cname=cd.get_help_cname(),
        )
        formatted_string += "\n".join(
            [createcd(child) for child in cd.subcommands or []]
        )
    elif cd.type == CD_TYPE_OLDINPUT:
        formatted_string = DEFINE_OLDINPUT_TEMPLATE.format(
            cname=cd.cname,
            parent_cname=cd.parent.cname,
            name=strornull(cd.name),
            handler_cname=cd.get_handler_cname(),
            help_cname=cd.get_help_cname(),
        )
        formatted_string += "\n".join(
            [createcd(child) for child in cd.subcommands or []]
        )
    elif cd.type == CD_TYPE_GROUP:
        formatted_string = createcd_typegroup(cd)
    else:
        raise Exception("Not handled cd type")
 
    return formatted_string
 
 
def arg2decl(cd):
    return DECL_DESC_HELP_ARGS_TEMPLATE.format(
        cname=CmdDesc.get_arg_cname(cd), size=len(cd.args) + 1
    )
 
 
def detail2decl(cd):
    return DECL_DESC_HELP_DETAILS_TEMPLATE.format(
        cname=CmdDesc.get_detail_cname(cd), size=len(cd.details) + 1
    )
 
 
def handler2decl(cd, cd_type, handler_name):
    out = []
    if cd_type == CD_TYPE_ARGV:
        out.append(
            "RZ_IPI RzCmdStatus %s(RzCore *core, int argc, const char **argv);"
            % (handler_name,)
        )
    if cd_type == CD_TYPE_ARGV_MODES:
        out.append(
            "RZ_IPI RzCmdStatus %s(RzCore *core, int argc, const char **argv, RzOutputMode mode);"
            % (handler_name,)
        )
    if cd_type == CD_TYPE_ARGV_STATE:
        out.append(
            "RZ_IPI RzCmdStatus %s(RzCore *core, int argc, const char **argv, RzCmdStateOutput *state);"
            % (handler_name,)
        )
    if cd_type == CD_TYPE_OLDINPUT:
        out.append("RZ_IPI int %s(void *data, const char *input);" % (handler_name,))
 
    if cd.details_cb is not None:
        out.append(
            "RZ_IPI RzCmdDescDetail *%s(RzCore *core, int argc, const char **argv);"
            % (cd.details_cb,)
        )
 
    if isinstance(cd.args, list):
        for arg in cd.args:
            d = arg.decl()
            if d is not None:
                out.append(d)
 
    return "\n".join(out) if out else None
 
 
parser = argparse.ArgumentParser(
    description="Generate .c/.h files from Command Descriptors YAML file."
)
parser.add_argument(
    "--src-output-dir", type=str, required=False, help="Source output directory"
)
parser.add_argument("--output-dir", type=str, required=True, help="Output directory")
parser.add_argument(
    "yaml_files",
    type=argparse.FileType("r"),
    nargs="+",
    help="Input YAML files containing commands descriptions. One should be named 'root'.",
)
 
args = parser.parse_args()
 
commands_yml_arr = [yaml.safe_load(f) for f in args.yaml_files]
commands_yml = {c["name"]: c["commands"] for c in commands_yml_arr}
 
root_cd = CmdDesc(commands_yml, None)
root_cds = [CmdDesc(commands_yml, c, root_cd) for c in commands_yml["root"]]
 
arg_decls = [arg2decl(cd) for cd in CmdDesc.c_args.values()]
detail_decls = [detail2decl(cd) for cd in CmdDesc.c_details.values()]
helps = [str(cd) for cd in root_cds]
init_code = [createcd(cd) for cd in root_cds]
 
cf_text = CMDDESCS_C_TEMPLATE.format(
    helps_declarations="\n".join(detail_decls + arg_decls),
    helps="\n".join(helps),
    init_code="\n".join(init_code),
)
with open(os.path.join(args.output_dir, "cmd_descs.c"), "w", encoding="utf8") as f:
    f.write(cf_text)
if args.src_output_dir:
    with open(
        os.path.join(args.src_output_dir, "cmd_descs.c"), "w", encoding="utf8"
    ) as f:
        f.write(cf_text)
 
handlers_decls = filter(
    lambda th: th[2] is not None,
    [(cd, cd.type, cd.get_handler_cname()) for cd in CmdDesc.c_cds.values()],
)
 
hf_text = CMDDESCS_H_TEMPLATE.format(
    handlers_declarations="\n".join(
        [handler2decl(cd, t, h) for cd, t, h in handlers_decls]
    ),
)
with open(os.path.join(args.output_dir, "cmd_descs.h"), "w", encoding="utf8") as f:
    f.write(hf_text)
if args.src_output_dir:
    with open(
        os.path.join(args.src_output_dir, "cmd_descs.h"), "w", encoding="utf8"
    ) as f:
        f.write(hf_text)