use pythonrs::ReportOrder;
use std::process::ExitCode;
fn main() -> ExitCode {
std::thread::Builder::new()
.stack_size(512 * 1024 * 1024)
.spawn(run_main)
.expect("spawn interpreter thread")
.join()
.unwrap_or(ExitCode::FAILURE)
}
fn run_main() -> ExitCode {
if pythonrs::pyhash::parse_hash_seed(std::env::var("PYTHONHASHSEED").ok().as_deref()).is_none()
{
eprintln!(
"Fatal Python error: config_init_hash_seed: PYTHONHASHSEED must be \"random\" \
or an integer in range [0; 4294967295]\nPython runtime state: preinitialized\n"
);
return ExitCode::FAILURE;
}
if pythonrs::host::parse_int_max_str_digits(
std::env::var("PYTHONINTMAXSTRDIGITS").ok().as_deref(),
)
.is_none()
{
eprintln!(
"Fatal Python error: config_init_int_max_str_digits: PYTHONINTMAXSTRDIGITS: \
invalid limit; must be >= 640 or 0 for unlimited.\nPython runtime state: \
preinitialized\n"
);
return ExitCode::FAILURE;
}
let raw: Vec<String> = std::env::args().collect();
let boundary = program_boundary(&raw);
let cli = pythonrs::cli::parse_from(&raw[..boundary]);
if cli.unbuffered {
std::env::set_var("PYTHONUNBUFFERED", "1");
}
if !cli.warnings.is_empty() {
std::env::set_var("PYTHONWARNINGS", cli.warnings.join(","));
}
if cli.optimize > 0 {
std::env::set_var("PYTHONOPTIMIZE", cli.optimize.to_string());
}
if cli.lsp {
return match pythonrs::lsp::run() {
Ok(()) => ExitCode::SUCCESS,
Err(e) => fail(&e),
};
}
if cli.dap {
return match pythonrs::dap::run() {
Ok(()) => ExitCode::SUCCESS,
Err(e) => fail(&e),
};
}
if cli.doctor {
return ExitCode::from((pythonrs::extensions::doctor::run() & 0xFF) as u8);
}
if cli.cacheview {
return ExitCode::from((pythonrs::extensions::cacheview::run() & 0xFF) as u8);
}
if cli.cache_clear {
return match pythonrs::cache::clear() {
Ok(()) => {
println!(
"python: bytecode cache cleared ({})",
pythonrs::cache::default_cache_path().display()
);
ExitCode::SUCCESS
}
Err(e) => fail(&format!("--cache-clear: {e}")),
};
}
let (prog, args) = parse_program(&raw[boundary..]);
match prog {
Prog::Module(module) => {
let code = pythonrs::run_module(&module, &args);
ExitCode::from((code & 0xFF) as u8)
}
Prog::Command(src) => {
let mut argv = vec!["-c".to_string()];
argv.extend(args);
let src = dedent_command(&src);
process_exit(pythonrs::run_main_program(
&src,
argv,
None,
"<string>",
true,
ReportOrder::ReportThenFlush,
))
}
Prog::Stdin => {
let src = std::io::read_to_string(std::io::stdin()).unwrap_or_default();
let mut argv = vec!["-".to_string()];
argv.extend(args);
process_exit(pythonrs::run_main_program(
&src,
argv,
None,
"<stdin>",
false,
ReportOrder::FlushThenReport,
))
}
Prog::Script(file) => run_script(&cli, file, args),
Prog::MissingArg(opt) => fail_usage(&format!("Argument expected for the {opt} option")),
Prog::None => {
if atty_stdin() {
pythonrs::repl::run();
return ExitCode::SUCCESS;
}
if cli.repl {
pythonrs::repl::run_piped();
return ExitCode::SUCCESS;
}
let src = std::io::read_to_string(std::io::stdin()).unwrap_or_default();
let mut argv = vec![String::new()];
argv.extend(args);
process_exit(pythonrs::run_main_program(
&src,
argv,
None,
"<stdin>",
false,
ReportOrder::FlushThenReport,
))
}
}
}
fn run_script(cli: &pythonrs::cli::Cli, file: String, args: Vec<String>) -> ExitCode {
if cli.dump_bytecode {
return match dump(&file) {
Ok(()) => ExitCode::SUCCESS,
Err(e) => fail(&e),
};
}
if cli.dump_tokens {
return match dump_tokens(&file) {
Ok(()) => ExitCode::SUCCESS,
Err(e) => fail(&e),
};
}
if cli.dump_ast {
return match dump_ast(&file) {
Ok(()) => ExitCode::SUCCESS,
Err(e) => fail(&e),
};
}
if cli.disasm {
return match disasm(&file) {
Ok(()) => ExitCode::SUCCESS,
Err(e) => fail(&e),
};
}
if cli.tiers {
return match std::fs::read_to_string(&file)
.map_err(|e| format!("cannot read {file}: {e}"))
.and_then(|src| pythonrs::tiers::report(&src))
{
Ok(r) => {
println!("{r}");
ExitCode::SUCCESS
}
Err(e) => fail(&e),
};
}
if cli.build {
return match pythonrs::aot::build(&file) {
Ok(msg) => {
println!("{msg}");
ExitCode::SUCCESS
}
Err(e) => fail(&e),
};
}
let src = match std::fs::read_to_string(&file) {
Ok(s) => s,
Err(e) => return fail(&format!("cannot read {file}: {e}")),
};
let abs = abs_path(&file);
let mut argv = vec![file];
argv.extend(args);
process_exit(pythonrs::run_main_program(
&src,
argv,
Some(abs.clone()),
&abs,
true,
ReportOrder::FlushThenReport,
))
}
fn dedent_command(src: &str) -> String {
let Some(first) = src.lines().find(|l| !l.trim().is_empty()) else {
return src.to_string();
};
let prefix: String = first
.chars()
.take_while(|c| *c == ' ' || *c == '\t')
.collect();
if prefix.is_empty() {
return src.to_string();
}
if !src
.lines()
.filter(|l| !l.trim().is_empty())
.all(|l| l.starts_with(&prefix))
{
return src.to_string();
}
src.lines()
.map(|l| l.strip_prefix(&prefix).unwrap_or(l))
.collect::<Vec<_>>()
.join("\n")
}
enum Prog {
Command(String),
Module(String),
Script(String),
Stdin,
MissingArg(&'static str),
None,
}
fn program_boundary(raw: &[String]) -> usize {
let mut i = 1;
while i < raw.len() {
let a = &raw[i];
if a == "-c"
|| a == "-m"
|| a == "-"
|| a == "--"
|| ((a.starts_with("-c") || a.starts_with("-m")) && a.len() > 2)
{
return i;
}
if a == "-W" {
i += 2; continue;
}
if a.starts_with('-') && a.len() > 1 {
i += 1; continue;
}
return i; }
raw.len()
}
fn parse_program(region: &[String]) -> (Prog, Vec<String>) {
let Some(first) = region.first() else {
return (Prog::None, Vec::new());
};
let rest = |n: usize| region.get(n..).map(<[String]>::to_vec).unwrap_or_default();
match first.as_str() {
"-c" => match region.get(1) {
Some(src) => (Prog::Command(src.clone()), rest(2)),
None => (Prog::MissingArg("-c"), Vec::new()),
},
"-m" => match region.get(1) {
Some(m) => (Prog::Module(m.clone()), rest(2)),
None => (Prog::MissingArg("-m"), Vec::new()),
},
"-" => (Prog::Stdin, rest(1)),
"--" => match region.get(1) {
Some(f) => (Prog::Script(f.clone()), rest(2)),
None => (Prog::None, Vec::new()),
},
s if s.starts_with("-c") => (Prog::Command(s[2..].to_string()), rest(1)),
s if s.starts_with("-m") => (Prog::Module(s[2..].to_string()), rest(1)),
s => (Prog::Script(s.to_string()), rest(1)),
}
}
fn fail_usage(msg: &str) -> ExitCode {
eprintln!("python: {msg}");
ExitCode::from(2)
}
fn process_exit(code: i32) -> ExitCode {
ExitCode::from((code & 0xFF) as u8)
}
fn abs_path(file: &str) -> String {
let p = std::path::Path::new(file);
if p.is_absolute() {
return file.to_string();
}
match std::env::current_dir() {
Ok(cwd) => cwd.join(file).to_string_lossy().into_owned(),
Err(_) => file.to_string(),
}
}
fn dump(file: &str) -> Result<(), String> {
let src = std::fs::read_to_string(file).map_err(|e| format!("cannot read {file}: {e}"))?;
let prog = pythonrs::compile(&src)?;
println!("== main ==\n{:#?}", prog.main.ops);
for (name, m) in &prog.functions {
println!(
"== def {name} ({}) ==\n{:#?}",
m.params.join(", "),
m.chunk.ops
);
}
for (i, p) in prog.procs.iter().enumerate() {
println!("== block #{i} ==\n{:#?}", p.chunk.ops);
}
Ok(())
}
fn dump_tokens(file: &str) -> Result<(), String> {
let src = std::fs::read_to_string(file).map_err(|e| format!("cannot read {file}: {e}"))?;
let lexed = pythonrs::lexer::lex(&src)?;
for t in lexed.toks {
println!("{}\t{:?}", t.line, t.tok);
}
match lexed.deferred {
Some(e) => Err(e),
None => Ok(()),
}
}
fn dump_ast(file: &str) -> Result<(), String> {
let src = std::fs::read_to_string(file).map_err(|e| format!("cannot read {file}: {e}"))?;
let stmts = pythonrs::parser::parse(&src)?;
println!("{stmts:#?}");
Ok(())
}
fn disasm(file: &str) -> Result<(), String> {
let src = std::fs::read_to_string(file).map_err(|e| format!("cannot read {file}: {e}"))?;
let prog = pythonrs::compile(&src)?;
println!("; python fusevm — main\n{}", prog.main.disassemble());
for (name, m) in &prog.functions {
println!(
"; python fusevm — def {name}({})\n{}",
m.params.join(", "),
m.chunk.disassemble()
);
}
for (i, p) in prog.procs.iter().enumerate() {
println!("; python fusevm — block #{i}\n{}", p.chunk.disassemble());
}
Ok(())
}
fn atty_stdin() -> bool {
unsafe { libc::isatty(libc::STDIN_FILENO) == 1 }
}
fn fail(msg: &str) -> ExitCode {
let (msg, _) = pythonrs::parser::split_syntax_error(msg);
eprintln!("python: {msg}");
ExitCode::FAILURE
}