static int run()

in src/tool/cppxlang/main.cpp [214:327]
97 lines of code
26 McCabe index (conditional complexity)

    static int run(int const argc, char** argv)
    {
        int result{};
        writer w;

        try
        {
            auto start = get_start_time();
            process_args(argc, argv);
            cache c{ get_files_to_cache() };
            remove_foundation_types(c);
            build_filters(c);
            settings.base = settings.base || (!settings.component && settings.projection_filter.empty());

            if (settings.verbose)
            {
                w.write(" tool:  %\n", canonical(argv[0]).string());
                w.write(" ver:   %\n", XLANG_VERSION_STRING);

                for (auto&& file : settings.input)
                {
                    w.write(" in:    %\n", file);
                }

                for (auto&& file : settings.reference)
                {
                    w.write(" ref:   %\n", file);
                }

                w.write(" out:   %\n", settings.output_folder);

                if (!settings.component_folder.empty())
                {
                    w.write(" cout:  %\n", settings.component_folder);
                }
            }

            w.flush_to_console();
            task_group group;

            for (auto&&[ns, members] : c.namespaces())
            {
                group.add([&, &ns = ns, &members = members]
                {
                    if (!has_projected_types(members) || !settings.projection_filter.includes(members))
                    {
                        return;
                    }

                    write_namespace_0_h(ns, members);
                    write_namespace_1_h(ns, members);
                    write_namespace_2_h(ns, members, c);
                    write_namespace_h(c, ns, members);
                });
            }

            group.add([&]
            {
                if (settings.base)
                {
                    write_base_h();
                    write_coroutine_h();
                }

                if (settings.component)
                {
                    std::vector<TypeDef> classes;

                    for (auto&&[ns, members] : c.namespaces())
                    {
                        for (auto&& type : members.classes)
                        {
                            if (settings.component_filter.includes(type))
                            {
                                classes.push_back(type);
                            }
                        }
                    }

                    if (!classes.empty())
                    {
                        write_module_g_cpp(classes);

                        for (auto&& type : classes)
                        {
                            write_component_g_h(type);
                            write_component_g_cpp(type);
                            write_component_h(type);
                            write_component_cpp(type);
                        }
                    }
                }
            });

            group.get();

            if (settings.verbose)
            {
                w.write(" time:  %ms\n", get_elapsed_time(start));
            }
        }
        catch (usage_exception const&)
        {
            print_usage(w);
        }
        catch (std::exception const& e)
        {
            w.write(" error: %\n", e.what());
            result = 1;
        }

        w.flush_to_console();
        return result;
    }