use std::{
ffi::{OsStr, OsString},
path::{Path, PathBuf},
};
use xold::search::{self, LibKind};
use super::next_os;
#[derive(Default)]
pub struct Inputs {
pub paths: Vec<PathBuf>,
pub from_l: Vec<bool>,
pub search: Vec<PathBuf>,
pub sysroot: Option<PathBuf>,
pub macho_libraries: bool,
pub in_lib: bool,
pub group: Vec<PathBuf>,
pub lib_groups: Vec<(usize, usize)>,
pub as_needed_flags: Vec<bool>,
pub kind: LibKind,
pub as_needed: bool,
pub state: Vec<(LibKind, bool)>,
}
impl Inputs {
pub fn file(&mut self, path: &OsStr) {
let path = PathBuf::from(path);
if self.in_lib {
self.group.push(path);
} else {
self.paths.push(path);
self.from_l.push(false);
self.as_needed_flags.push(self.as_needed);
}
}
pub fn library(&mut self, name: &str) -> std::result::Result<(), String> {
if self.in_lib {
return Err(
"xold: -l cannot appear between --start-lib and --end-lib"
.into(),
);
}
let path = if self.macho_libraries && self.kind == LibKind::Any {
macho_library(name, &self.search, self.sysroot.as_deref())?
} else {
library(name, &self.search, self.sysroot.as_deref(), self.kind)?
};
self.paths.push(path);
self.from_l.push(true);
self.as_needed_flags.push(self.as_needed);
Ok(())
}
pub fn push_state(&mut self) {
self.state.push((self.kind, self.as_needed));
}
pub fn pop_state(&mut self) -> std::result::Result<(), String> {
let Some((kind, as_needed)) = self.state.pop() else {
return Err("xold: --pop-state without --push-state".into());
};
self.kind = kind;
self.as_needed = as_needed;
Ok(())
}
pub const fn begin_lib(&mut self) {
self.in_lib = true;
}
pub fn end_lib(&mut self) {
let start = self.paths.len();
let as_needed = self.as_needed;
for path in self.group.drain(..) {
self.paths.push(path);
self.from_l.push(false);
self.as_needed_flags.push(as_needed);
}
if self.paths.len() > start {
self.lib_groups.push((start, self.paths.len()));
}
self.in_lib = false;
}
}
pub fn parse_sysroot(
args: &[OsString],
) -> std::result::Result<Option<PathBuf>, String> {
let mut sysroot = None;
let mut i = 0;
while i < args.len() {
let Some(arg) = args[i].to_str() else {
i += 1;
continue;
};
if arg == "--sysroot" || arg == "-syslibroot" {
i += 1;
sysroot = Some(PathBuf::from(next_os(args, i, arg)?));
} else if let Some(path) = arg.strip_prefix("--sysroot=") {
sysroot = Some(PathBuf::from(path));
}
i += 1;
}
Ok(sysroot)
}
pub fn has_syslibroot(args: &[OsString]) -> bool {
args.iter().any(|arg| arg == "-syslibroot")
}
pub fn parse_search_path(
args: &[OsString],
) -> std::result::Result<Vec<PathBuf>, String> {
let mut search = Vec::new();
let mut i = 0;
while i < args.len() {
let Some(arg) = args[i].to_str() else {
i += 1;
continue;
};
if arg == "-L" {
i += 1;
search.push(PathBuf::from(next_os(args, i, "-L")?));
} else if let Some(dir) =
arg.strip_prefix("-L").filter(|d| !d.is_empty())
{
search.push(PathBuf::from(dir));
}
i += 1;
}
Ok(search)
}
pub fn library(
name: &str,
search_path: &[PathBuf],
sysroot: Option<&Path>,
kind: LibKind,
) -> std::result::Result<PathBuf, String> {
search::find_library_kind(name, search_path, sysroot, kind).ok_or_else(
|| match kind {
LibKind::Any => format!("xold: cannot find -l{name}"),
LibKind::ArchiveOnly => format!(
"xold: cannot find -l{name}: -Bstatic is in force, so only \
lib{name}.a was looked for"
),
},
)
}
fn macho_library(
name: &str,
search_path: &[PathBuf],
sysroot: Option<&Path>,
) -> std::result::Result<PathBuf, String> {
search::find_macho_library(name, search_path, sysroot)
.ok_or_else(|| format!("xold: cannot find Mach-O -l{name}"))
}