rascal_cli 0.2.1

A parser and compiler for Flash ActionScript 2 files into SWFs
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

use anyhow::Result;
use clap::Parser;
use rascal::FileSystemSourceProvider;
use rascal::ProgramBuilder;
use std::fs;
use std::path::PathBuf;

#[derive(Parser, Debug)]
#[command(name = "rascal", version, author, about)]
struct Opt {
    /// A loose script (not class file) to add to the compiled program.
    ///
    /// Multiple scripts may be added to one program.
    /// Scripts will be executed in order that they are added, before any classes are loaded.
    ///
    /// It is valid to not specify any scripts - if so, the entry point of the program will be the first
    /// class (see `--class`) that contains a `static function main()` method.
    #[arg(name = "SCRIPT", help_heading = "Inputs")]
    script: Vec<PathBuf>,

    /// Output file path. This will be overwritten if it already exists.
    ///
    /// If not specified:
    /// - If there are any scripts (see `SCRIPT`) specified, the first one will be used to determine the output path.
    /// - `output.swf` will be used if all else fails.
    #[arg(
        short,
        long,
        verbatim_doc_comment,
        help_heading = "Generated SWF Options"
    )]
    output: Option<PathBuf>,

    /// A name of a class to be added to the compiled program.
    ///
    /// This should be the canonical name of a class (e.g. `Foo` or `foo.bar.Baz`) which should be found in the current directory
    /// (e.g. at `Foo.as` or `foo/bar/Baz.as`).
    ///
    /// All classes will be loaded after any scripts (see `SCRIPT`).
    /// If no scripts are specified, one (and only one) class is expected to have an entry point in
    /// the form of a `static function main()` method.
    #[arg(short, long, help_heading = "Inputs")]
    class: Vec<String>,

    /// Adds a directory to be searched for classes.
    ///
    /// If no classpaths are specified, the current working directory will be used instead.
    #[arg(long, long, help_heading = "Inputs")]
    classpath: Vec<PathBuf>,

    /// SWF version to use.
    #[arg(
        short = 'v',
        long,
        default_value_t = 15,
        help_heading = "Generated SWF Options"
    )]
    swf_version: u8,

    /// Frame rate of the output SWF.
    #[arg(long, default_value_t = 24.0, help_heading = "Generated SWF Options")]
    frame_rate: f32,
}

fn main() -> Result<()> {
    let mut opt = Opt::parse();

    if opt.classpath.is_empty() {
        opt.classpath.push(PathBuf::from("."));
    }
    let provider = FileSystemSourceProvider::with_roots(opt.classpath);
    let mut builder = ProgramBuilder::new(provider);

    for src in &opt.script {
        builder.add_script(&src.file_name().unwrap().to_string_lossy());
    }
    for class in &opt.class {
        builder.add_class(class);
    }

    let parsed = builder.build().unwrap_or_else(|e| panic!("{}", e));
    let pcode = parsed.compile(opt.swf_version);
    let output_path = opt
        .output
        .or_else(|| opt.script.first().map(|s| s.with_extension("swf")))
        .unwrap_or_else(|| PathBuf::from("output.swf"));
    let swf = pcode.to_swf(opt.frame_rate)?;
    fs::write(&output_path, swf)?;
    Ok(())
}