tutorial_codegen.cpp

// AI Generated 2026 Ryan P. Nicholl <rnicholl@protonmail.com>
// SPDX-License-Identifier: Apache-2.0
 
#include "tutorial_support.hpp"
 
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <rpnx/cortado/builders.hpp>
#include <rpnx/cortado/jar.hpp>
#include <rpnx/cortado/validation.hpp>
#include <span>
#include <stdexcept>
#include <string>
#include <vector>
 
int main(int argument_count, char const* const* argument_values)
try
{
    std::filesystem::path const output_directory = argument_count == 2 ? std::filesystem::path(argument_values[1]) : std::filesystem::current_path();
    std::filesystem::create_directories(output_directory);
 
    // [create-class]
    rpnx::cortado::class_file_builder builder("tutorial/Generated", "java/lang/Object", {0, 61});
    static_cast< void >(builder.add_field(
        "invocations",
        "I",
        rpnx::cortado::field_access_flags::is_public |
            rpnx::cortado::field_access_flags::is_static));
 
    rpnx::cortado::code_builder constructor;
    constructor.aload({0})
        .invokespecial("java/lang/Object", "<init>", "()V")
        .append< rpnx::cortado::opcode::return_ >();
    static_cast< void >(builder.add_method(
        "<init>",
        "()V",
        rpnx::cortado::method_access_flags::is_public,
        constructor));
    // [create-class]
 
    // [sum-to]
    rpnx::cortado::code_builder sum_to;
    rpnx::cortado::label const sum_entry = sum_to.new_label();
    rpnx::cortado::label const sum_loop = sum_to.new_label();
    rpnx::cortado::label const sum_done = sum_to.new_label();
    rpnx::cortado::label const sum_end = sum_to.new_label();
 
    sum_to.bind(sum_entry)
        .append< rpnx::cortado::opcode::iconst_0 >()
        .istore({1})
        .append< rpnx::cortado::opcode::iconst_1 >()
        .istore({2})
        .bind(sum_loop)
        .iload({2})
        .iload({0})
        .branch< rpnx::cortado::opcode::if_icmpgt >(sum_done)
        .iload({1})
        .iload({2})
        .append< rpnx::cortado::opcode::iadd >()
        .istore({1})
        .iinc({2}, 1)
        .branch< rpnx::cortado::opcode::goto_ >(sum_loop)
        .bind(sum_done)
        .iload({1})
        .append< rpnx::cortado::opcode::ireturn >()
        .bind(sum_end);
 
    sum_to.add_line_number(sum_entry, 10)
        .add_line_number(sum_loop, 12)
        .add_line_number(sum_done, 16)
        .add_local_variable(sum_entry, sum_end, "limit", "I", {0})
        .add_local_variable(sum_entry, sum_end, "sum", "I", {1})
        .add_local_variable(sum_entry, sum_end, "index", "I", {2});
 
    static_cast< void >(builder.add_method(
        "sumTo",
        "(I)I",
        rpnx::cortado::method_access_flags::is_public |
            rpnx::cortado::method_access_flags::is_static,
        sum_to));
    // [sum-to]
 
    // [sparse-switch]
    rpnx::cortado::code_builder classify;
    rpnx::cortado::label const zero_case = classify.new_label();
    rpnx::cortado::label const one_case = classify.new_label();
    rpnx::cortado::label const other_case = classify.new_label();
 
    classify.iload({0}).lookupswitch(
        other_case,
        {{0, zero_case}, {1, one_case}});
    classify.bind(zero_case)
        .ldc_string("zero")
        .append< rpnx::cortado::opcode::areturn >();
    classify.bind(one_case)
        .ldc_string("one")
        .append< rpnx::cortado::opcode::areturn >();
    classify.bind(other_case)
        .ldc_string("many")
        .append< rpnx::cortado::opcode::areturn >();
 
    static_cast< void >(builder.add_method(
        "classify",
        "(I)Ljava/lang/String;",
        rpnx::cortado::method_access_flags::is_public |
            rpnx::cortado::method_access_flags::is_static,
        classify));
    // [sparse-switch]
 
    // [exception-handler]
    rpnx::cortado::code_builder safe_divide;
    rpnx::cortado::label const protected_start = safe_divide.new_label();
    rpnx::cortado::label const protected_end = safe_divide.new_label();
    rpnx::cortado::label const arithmetic_handler = safe_divide.new_label();
 
    safe_divide.bind(protected_start)
        .iload({0})
        .iload({1})
        .append< rpnx::cortado::opcode::idiv >()
        .append< rpnx::cortado::opcode::ireturn >()
        .bind(protected_end)
        .bind(arithmetic_handler)
        .astore({2})
        .append< rpnx::cortado::opcode::iconst_0 >()
        .append< rpnx::cortado::opcode::ireturn >();
    safe_divide.add_exception_handler(
        protected_start,
        protected_end,
        arithmetic_handler,
        "java/lang/ArithmeticException");
 
    static_cast< void >(builder.add_method(
        "safeDivide",
        "(II)I",
        rpnx::cortado::method_access_flags::is_public |
            rpnx::cortado::method_access_flags::is_static,
        safe_divide));
    // [exception-handler]
 
    // [reference-merge]
    rpnx::cortado::code_builder select_collection;
    rpnx::cortado::label const use_map = select_collection.new_label();
    rpnx::cortado::label const collection_selected = select_collection.new_label();
    select_collection.iload({0})
        .branch< rpnx::cortado::opcode::ifeq >(use_map)
        .aload({1})
        .branch< rpnx::cortado::opcode::goto_ >(collection_selected)
        .bind(use_map)
        .aload({2})
        .bind(collection_selected)
        .append< rpnx::cortado::opcode::areturn >();
 
    rpnx::cortado::examples::tutorial_class_hierarchy hierarchy;
    static_cast< void >(builder.add_method(
        "selectCollection",
        "(ZLjava/util/ArrayList;Ljava/util/HashMap;)Ljava/lang/Object;",
        rpnx::cortado::method_access_flags::is_public |
            rpnx::cortado::method_access_flags::is_static,
        select_collection,
        {},
        rpnx::cortado::class_hierarchy_resolver_ref(hierarchy)));
    // [reference-merge]
 
    // [validate-and-serialize]
    rpnx::cortado::class_file const generated_class = builder.build();
    rpnx::cortado::validation_report const report = rpnx::cortado::validate_class_file(generated_class);
    if (!report.valid())
    {
        throw std::runtime_error(report.diagnostics.front().message);
    }
    std::vector< std::byte > const class_bytes = rpnx::cortado::serialize_class_file(generated_class);
    // [validate-and-serialize]
 
    // [package-jar]
    std::string const manifest_text = "Manifest-Version: 1.0\n\n";
    std::vector< std::byte > manifest_bytes;
    manifest_bytes.reserve(manifest_text.size());
    for (char const character : manifest_text)
    {
        manifest_bytes.push_back(static_cast< std::byte >(static_cast< std::uint8_t >(character)));
    }
 
    rpnx::cortado::jar_file archive;
    archive.entries.push_back(rpnx::cortado::jar_entry{
        .name = "META-INF/MANIFEST.MF",
        .data = std::move(manifest_bytes),
        .compression = rpnx::cortado::compression_method::stored,
        .flags = rpnx::cortado::jar_entry_flags::utf8_names,
        .modification_date = rpnx::cortado::zip_dos_date{0x0021}});
    archive.entries.push_back(rpnx::cortado::jar_entry{
        .name = "tutorial/Generated.class",
        .data = class_bytes,
        .compression = rpnx::cortado::compression_method::deflated,
        .flags = rpnx::cortado::jar_entry_flags::utf8_names,
        .modification_date = rpnx::cortado::zip_dos_date{0x0021}});
    std::vector< std::byte > const jar_bytes = rpnx::cortado::serialize_jar(archive);
    // [package-jar]
 
    auto write_binary_file = [](std::filesystem::path const& path, std::span< std::byte const > bytes)
    {
        std::ofstream output(path, std::ios::binary | std::ios::trunc);
        if (!output)
        {
            throw std::runtime_error("could not open " + path.string());
        }
        output.write(reinterpret_cast< char const* >(bytes.data()), static_cast< std::streamsize >(bytes.size()));
        if (!output)
        {
            throw std::runtime_error("could not write " + path.string());
        }
    };
 
    std::filesystem::path const package_directory = output_directory / "tutorial";
    std::filesystem::create_directories(package_directory);
    write_binary_file(package_directory / "Generated.class", class_bytes);
    write_binary_file(output_directory / "tutorial-codegen.jar", jar_bytes);
    return 0;
}
catch (std::exception const& error)
{
    std::cerr << error.what() << '\n';
    return 1;
}