thru-abi-gen 0.2.30

ABI code generation utilities for the Thru blockchain
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#![allow(dead_code)]
#![allow(unused_imports)]

use clap::{Parser, Subcommand, ValueEnum};
use cmds::analyze::IrOutputFormat;
use std::path::PathBuf;

mod abi;
mod cmds;
mod codegen;
mod dependency;

#[derive(Parser)]
#[command(name = "abi")]
#[command(about = "ABI code generation tool for thru-net", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /* Generate code from ABI type definitions */
    Codegen {
        /* Input YAML files containing type definitions */
        #[arg(short = 'f', long = "files", value_name = "FILE", required = true)]
        files: Vec<PathBuf>,

        /* Include directories for imported type files */
        #[arg(short = 'i', long = "include-dir", value_name = "DIR")]
        include_dirs: Vec<PathBuf>,

        /* Target language for code generation */
        #[arg(short = 'l', long = "language", value_enum)]
        language: Language,

        /* Output directory for generated code */
        #[arg(
            short = 'o',
            long = "output",
            value_name = "DIR",
            default_value = "generated"
        )]
        output_dir: PathBuf,

        /* Enable verbose output */
        #[arg(short = 'v', long = "verbose")]
        verbose: bool,
    },

    /* Analyze ABI type definitions and show detailed type information */
    Analyze {
        /* Input YAML files containing type definitions */
        #[arg(short = 'f', long = "files", value_name = "FILE", required = true)]
        files: Vec<PathBuf>,

        /* Include directories for imported type files */
        #[arg(short = 'i', long = "include-dir", value_name = "DIR")]
        include_dirs: Vec<PathBuf>,

        /* Print the shared layout IR (JSON) after analysis */
        #[arg(long = "print-ir")]
        print_ir: bool,

        /* Format to use when printing the shared layout IR */
        #[arg(long = "ir-format", value_enum, default_value = "json")]
        ir_format: IrOutputFormat,

        /* Print the generated legacy + IR footprint helpers for a specific type */
        #[arg(long = "print-footprint", value_name = "TYPE")]
        print_footprint: Option<String>,

        /* Print the generated legacy + IR validate helpers for a specific type */
        #[arg(long = "print-validate", value_name = "TYPE")]
        print_validate: Option<String>,
    },
}

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum, Debug)]
enum Language {
    /* Generate C code (.h and .c files) */
    C,
    /* Generate Rust code (.rs files) */
    Rust,
    /* Generate TypeScript code (.ts files) */
    #[value(name = "typescript")]
    TypeScript,
}

impl From<Language> for cmds::codegen::Language {
    fn from(lang: Language) -> Self {
        match lang {
            Language::C => cmds::codegen::Language::C,
            Language::Rust => cmds::codegen::Language::Rust,
            Language::TypeScript => cmds::codegen::Language::TypeScript,
        }
    }
}

fn main() -> anyhow::Result<()> {
    let cli = Cli::parse();

    match cli.command {
        Commands::Codegen {
            files,
            include_dirs,
            language,
            output_dir,
            verbose,
        } => {
            cmds::codegen::run(files, include_dirs, language.into(), output_dir, verbose)?;
        }

        Commands::Analyze {
            files,
            include_dirs,
            print_ir,
            ir_format,
            print_footprint,
            print_validate,
        } => {
            cmds::analyze::run(
                files,
                include_dirs,
                print_ir,
                ir_format,
                print_footprint,
                print_validate,
            )?;
        }
    }

    Ok(())
}