use std::process::ExitCode;
const FATAL_EXIT: u8 = 255;
fn ran(_: phplang::Value) -> ExitCode {
match phplang::host::pending_exit() {
Some(status) => ExitCode::from(status as u8),
None => ExitCode::SUCCESS,
}
}
fn main() -> ExitCode {
let mut cli = phplang::cli::parse();
for d in &cli.define {
let (name, value) = match d.split_once('=') {
Some((n, v)) => (n, v),
None => (d.as_str(), "1"),
};
phplang::host::add_initial_ini(name.trim(), value.trim());
}
if cli.lsp {
return match phplang::lsp::run() {
Ok(()) => ExitCode::SUCCESS,
Err(e) => fail(&e),
};
}
if cli.dap {
return match phplang::dap::run() {
Ok(()) => ExitCode::SUCCESS,
Err(e) => fail(&e),
};
}
if let Some(code) = cli.run.take() {
let src = format!("<?php {code}");
let mut args = Vec::new();
args.extend(cli.file.take());
args.append(&mut cli.argv);
return match phplang::eval_cli(&src, &args) {
Ok(v) => ran(v),
Err(e) => fail(&e),
};
}
if let Some(file) = cli.file {
if cli.dump_bytecode {
return finish(dump(&file));
}
if cli.dump_tokens {
return finish(dump_tokens(&file));
}
if cli.dump_ast {
return finish(dump_ast(&file));
}
if cli.disasm {
return finish(disasm(&file));
}
if cli.tiers {
return finish(tiers(&file));
}
return match phplang::eval_file_cli(&file, &cli.argv) {
Ok(v) => ran(v),
Err(e) => fail(&e),
};
}
if cli.interactive || atty_stdin() {
phplang::repl::run();
return ExitCode::SUCCESS;
}
let src = {
use std::io::Read;
let mut b = Vec::new();
let _ = std::io::stdin().read_to_end(&mut b);
phplang::bytes::from_bytes(&b)
};
match phplang::eval_stdin_cli(&src, &cli.argv) {
Ok(v) => ran(v),
Err(e) => fail(&e),
}
}
fn fmt_params(params: &[phplang::host::Param]) -> String {
params
.iter()
.map(|p| {
let dots = if p.variadic { "..." } else { "" };
let def = if p.default.is_some() { " = …" } else { "" };
format!("{dots}${}{def}", p.name)
})
.collect::<Vec<_>>()
.join(", ")
}
fn dump(file: &str) -> Result<(), String> {
let src = std::fs::read(file)
.map(|b| phplang::bytes::from_bytes(&b))
.map_err(|e| format!("cannot read {file}: {e}"))?;
let prog = phplang::compile(&src)?;
println!("== main ==\n{:#?}", prog.main.ops);
for (name, f) in &prog.functions {
println!(
"== function {name}({}) ==\n{:#?}",
fmt_params(&f.params),
f.chunk.ops
);
}
Ok(())
}
fn dump_tokens(file: &str) -> Result<(), String> {
let src = std::fs::read(file)
.map(|b| phplang::bytes::from_bytes(&b))
.map_err(|e| format!("cannot read {file}: {e}"))?;
let src = phplang::rust_ffi::desugar(&src);
for t in phplang::lexer::lex(&src)? {
println!("{}\t{:?}", t.line, t.tok);
}
Ok(())
}
fn dump_ast(file: &str) -> Result<(), String> {
let src = std::fs::read(file)
.map(|b| phplang::bytes::from_bytes(&b))
.map_err(|e| format!("cannot read {file}: {e}"))?;
let stmts = phplang::parser::parse(&src)?;
println!("{stmts:#?}");
Ok(())
}
fn disasm(file: &str) -> Result<(), String> {
let src = std::fs::read(file)
.map(|b| phplang::bytes::from_bytes(&b))
.map_err(|e| format!("cannot read {file}: {e}"))?;
let prog = phplang::compile(&src)?;
println!("; php fusevm — main\n{}", prog.main.disassemble());
for (name, f) in &prog.functions {
println!(
"; php fusevm — function {name}({})\n{}",
fmt_params(&f.params),
f.chunk.disassemble()
);
}
Ok(())
}
fn tiers(file: &str) -> Result<(), String> {
let src = std::fs::read(file)
.map(|b| phplang::bytes::from_bytes(&b))
.map_err(|e| format!("cannot read {file}: {e}"))?;
println!("{}", phplang::tiers::report(&src)?);
Ok(())
}
fn finish(r: Result<(), String>) -> ExitCode {
match r {
Ok(()) => ExitCode::SUCCESS,
Err(e) => fail(&e),
}
}
fn atty_stdin() -> bool {
unsafe { libc::isatty(libc::STDIN_FILENO) == 1 }
}
fn fail(msg: &str) -> ExitCode {
if phplang::host::fatal_reported() {
return ExitCode::from(FATAL_EXIT);
}
eprintln!("php: {msg}");
ExitCode::FAILURE
}