wright 0.10.1

The wright programming language compiler and tooling.
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

//! Command line interface for wright.

use clap::{Parser, Subcommand};
use std::{io, path::PathBuf};
use wright::{
    lexer::Lexer,
    source_tracking::{source::Source, SourceMap, SourceRef},
};

/// The wright cli.
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None, arg_required_else_help = true)]
struct Cli {
    /// Whether the output should be only ASCII characters (default auto-detected, if `supports-unicode`
    /// crate is compiled in).
    ///
    /// This option does nothing if the `supports-unicode` crate was not enabled at compile time (in that case all
    /// output will be ASCII regardless).
    #[arg(short = 'A', long = "ascii")]
    force_ascii: bool,
    /// The subcommand passed to the wright cli.
    #[command(subcommand)]
    command: Command,
}

/// Different sub-commands that the wright cli supports.
#[derive(Subcommand, Debug)]
enum Command {
    /// Subcommand for debugging wright's source code and interpreter.
    Debug {
        #[command(subcommand)]
        command: DebugCommand,
    },

    /// Subcommand for showing information about this version of wright.
    Show {
        #[command(subcommand)]
        command: ShowCommand,
    },
}

/// Different sub-commands that the debug sub-command supports.
#[derive(Subcommand, Debug)]
enum DebugCommand {
    /// Debug the tokens/lexemes for a source file.
    Tokens {
        /// A file of wright source code.
        file: PathBuf,
        // /// Pretty print the source code with the tokens lined under them.
        // /// If not used, a list of tokens will be printed with their metadata.
        // #[arg(short, long)]
        // pretty: bool,
    },
}

/// Different subcommands that can be used to get info about a copy of the wright CLI/compiler/etc.
#[derive(Subcommand, Debug)]
enum ShowCommand {
    /// Get the version string of this copy of the wright compiler.
    Version,

    /// Get the full list of feature names/strings that were enabled when this copy of wright was compiled.
    Features,
}

fn main() -> io::Result<()> {
    // Parse the command line arguments.
    let cli: Cli = Cli::parse();

    #[cfg(feature = "supports-unicode")]
    {
        wright::util::supports_unicode::set_force_ascii(cli.force_ascii);
    }

    match cli.command {
        // Print all the tokens for a given file.
        Command::Debug {
            command: DebugCommand::Tokens { file },
        } => {
            let source_map: SourceMap = SourceMap::new();
            // Add the given file to the file map.
            let source_ref: SourceRef = source_map.add(Source::new_mapped_or_read(file)?);
            // Make a lexer over the entirety of the given file.
            let mut lexer: Lexer = Lexer::new(source_ref);
            // Get all the tokens from the lexer and print them each.
            while let Some(token) = lexer.next_token() {
                println!("{token}");
            }
        }

        Command::Show {
            command: ShowCommand::Version,
        } => {
            println!("wright {}", wright::build_info::PKG_VERSION);
        }

        Command::Show {
            command: ShowCommand::Features,
        } => {
            for feature in wright::build_info::FEATURES {
                println!("{feature}");
            }
        }
    }

    Ok(())
}