ironwork_rt/module/
library.rs

1//! The load modules a run has read and the directories it reads more from (load-module.md §8.2):
2//! a program found by the name a CALL or a function invocation gives, and a class by its external
3//! name, each as the VM holds it.
4
5use super::{DirectoryEntry, LoadedModule, SourceFile, read};
6use crate::bms::Mapset;
7use crate::lir::{Class, ClassPart, Program, SymId};
8use crate::oo::{ClassCode, JAVA_LANG_OBJECT, MethodCode, Part};
9use crate::unit::{FoundClass, LoadError, LoadedProgram};
10use crate::vm::Code;
11use std::path::{Path, PathBuf};
12use std::rc::Rc;
13
14/// What a program from a module must pass before the VM runs it, since a module is untrusted input.
15pub type Check = fn(&Program) -> Result<(), String>;
16
17/// Whether `name` can name a library member; any other name never reaches the filesystem.
18pub fn member_name(name: &str) -> bool {
19    !name.is_empty() && name.len() <= 30 && name.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '@' | '#' | '$'))
20}
21
22pub struct Modules {
23    /// Searched in order for `NAME.iwm`.
24    pub dirs: Vec<PathBuf>,
25    check: Check,
26    read: Vec<Read>,
27}
28
29/// A module the run has read: its directory, the programs no CALL has taken yet, its mapsets, the
30/// files each program's compile read, and whether the run began with it.
31struct Read {
32    path: PathBuf,
33    directory: Vec<DirectoryEntry>,
34    programs: Vec<Option<Program>>,
35    mapsets: Vec<Mapset>,
36    files: Vec<Vec<Option<SourceFile>>>,
37    first: bool,
38}
39
40type Found = LoadedProgram<Rc<Code>>;
41type FoundCode = FoundClass<Rc<ClassCode<Rc<Code>>>>;
42
43impl Modules {
44    pub fn new(dirs: Vec<PathBuf>, check: Check) -> Self {
45        Self { dirs, check, read: Vec::new() }
46    }
47
48    /// Registers a module read from `path`, whose programs are found by name from now on; its
49    /// number is what [`Modules::take`] takes.
50    pub fn add(&mut self, path: PathBuf, module: LoadedModule) -> usize {
51        self.register(path, module, false)
52    }
53
54    /// Registers the module the run began with, as [`Modules::add`] does; a program of the same
55    /// source as its program 0 is loaded with no files to record, as a program of the run's first
56    /// source is.
57    pub fn add_first(&mut self, path: PathBuf, module: LoadedModule) -> usize {
58        self.register(path, module, true)
59    }
60
61    fn register(&mut self, path: PathBuf, module: LoadedModule, first: bool) -> usize {
62        let LoadedModule { directory, programs, mapsets, files } = module;
63        self.read.push(Read { path, directory, programs: programs.into_iter().map(Some).collect(), mapsets, files, first });
64        self.read.len() - 1
65    }
66
67    /// Program `ordinal` of module `k` for the run unit, checked; None once taken.
68    pub fn take(&mut self, k: usize, ordinal: usize) -> Option<Result<Found, String>> {
69        let held = self.read.get_mut(k)?;
70        let program = held.programs.get_mut(ordinal)?.take()?;
71        let entry = &held.directory[ordinal];
72        let nested = held.directory.iter().filter(|e| e.parent == Some(ordinal as u32)).map(|e| e.id.clone()).collect();
73        let name = entry.load_name().to_ascii_uppercase();
74        let checked = (self.check)(&program).map_err(|e| format!("{}: program {}: {e}", held.path.display(), entry.id));
75        let own = held.files.get(ordinal).map(Vec::as_slice).unwrap_or_default();
76        let recorded = if held.first && own.first() == held.files.first().and_then(|f| f.first()) {
77            Vec::new()
78        } else {
79            program.debug.sources.iter().map(|&s| symbol(&program, s)).zip(own.iter().cloned()).collect()
80        };
81        Some(checked.map(|()| {
82            let code = code(program, nested, None);
83            let (files, size) = code.shape();
84            LoadedProgram { compiled: Rc::new(code), name, files, size, source: None, recorded }
85        }))
86    }
87
88    /// A program of a module already read that no CALL has taken, by the name a CALL gives: the
89    /// first such module, and in it the lowest ordinal.
90    pub fn loaded(&mut self, name: &str) -> Option<Result<Found, LoadError>> {
91        let (k, ordinal) = self.read.iter().enumerate().find_map(|(k, m)| m.untaken(|e| e.load_name().eq_ignore_ascii_case(name)).map(|o| (k, o)))?;
92        self.take(k, ordinal).map(|found| found.map_err(LoadError::Compile))
93    }
94
95    /// `NAME.iwm`, then `name.iwm`, in each directory in turn. A module found that cannot be read,
96    /// or that holds no program `NAME`, is an error, not "not found".
97    pub fn search(&mut self, name: &str) -> Result<Found, LoadError> {
98        if !member_name(name) {
99            return Err(LoadError::NotFound);
100        }
101        let Some(path) = self.file(&[name.to_owned(), name.to_ascii_lowercase()]) else { return Err(LoadError::NotFound) };
102        let module = open(&path).map_err(LoadError::Compile)?;
103        let Some(ordinal) = module.directory.iter().position(|e| e.load_name().eq_ignore_ascii_case(name)) else {
104            return Err(LoadError::Compile(format!("{}: the module holds no program {name}", path.display())));
105        };
106        let k = self.add(path, module);
107        match self.take(k, ordinal) {
108            Some(found) => found.map_err(LoadError::Compile),
109            None => Err(LoadError::NotFound),
110        }
111    }
112
113    /// The PROGRAM-ID of a program not yet taken, of a module already read, with this ENTRY name.
114    pub fn holder(&self, entry: &str) -> Option<String> {
115        self.read.iter().find_map(|m| m.untaken(|e| e.entries.iter().any(|(n, _)| n == entry)).map(|o| m.directory[o].id.to_ascii_uppercase()))
116    }
117
118    /// The COBOL class definition of this external name in a module already read, not yet taken.
119    pub fn loaded_class(&mut self, external: &str) -> Result<Option<FoundCode>, String> {
120        match self.read.iter().enumerate().find_map(|(k, m)| m.defining(external).map(|o| (k, o))) {
121            Some(found) => self.take_class(found).map(Some),
122            None => Ok(None),
123        }
124    }
125
126    /// The COBOL class definition of this external name in a module named as the source search
127    /// names the class's source (`numeric::assumptions::CLASS_SEARCH`), in each directory in turn.
128    pub fn search_class(&mut self, external: &str) -> Result<Option<FoundCode>, String> {
129        if external == JAVA_LANG_OBJECT {
130            return Ok(None);
131        }
132        let member = |n: &str| !n.is_empty() && n.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '$');
133        let simple = external.rsplit('.').next().unwrap_or(external).to_owned();
134        let mut names = vec![simple, external.replace('.', "_")];
135        names.dedup();
136        names.retain(|n| member(n));
137        let variants: Vec<String> = names.iter().flat_map(|n| [n.clone(), n.to_ascii_lowercase(), n.to_ascii_uppercase()]).collect();
138        for dir in self.dirs.clone() {
139            for variant in &variants {
140                let path = dir.join(format!("{variant}.iwm"));
141                if !path.is_file() {
142                    continue;
143                }
144                let module = open(&path)?;
145                let Some(ordinal) = module.programs.iter().position(|p| defines(p, external)) else { continue };
146                let k = self.add(path, module);
147                return self.take_class((k, ordinal)).map(Some);
148            }
149        }
150        Ok(None)
151    }
152
153    /// A mapset a module already read holds.
154    pub fn mapset(&self, name: &str) -> Option<Mapset> {
155        self.read.iter().find_map(|m| m.mapsets.iter().find(|s| s.name.eq_ignore_ascii_case(name))).cloned()
156    }
157
158    fn file(&self, names: &[String]) -> Option<PathBuf> {
159        self.dirs.iter().flat_map(|d| names.iter().map(move |n| d.join(format!("{n}.iwm")))).find(|p| p.is_file())
160    }
161
162    /// The class program at `(k, ordinal)`, checked, as the run unit's class table holds it, with
163    /// its source table.
164    fn take_class(&mut self, (k, ordinal): (usize, usize)) -> Result<FoundCode, String> {
165        let held = &mut self.read[k];
166        let Some(mut program) = held.programs[ordinal].take() else { return Err(format!("{}: program {ordinal} is taken", held.path.display())) };
167        (self.check)(&program).map_err(|e| format!("{}: class {}: {e}", held.path.display(), held.directory[ordinal].id))?;
168        let Some(class) = program.services.class.take() else { return Err(format!("{}: program {ordinal} is not a class", held.path.display())) };
169        let Class { parent, factory, object, methods, .. } = *class;
170        let sym = |id: SymId| symbol(&program, id);
171        let name = sym(program.id);
172        let part = |p: ClassPart| Part { data: Rc::new(code(p.data, Vec::new(), None)), records: p.records };
173        let methods = methods
174            .into_iter()
175            .map(|m| {
176                let method = sym(m.name);
177                MethodCode {
178                    factory: m.factory,
179                    params: m.params.iter().map(|&p| sym(p)).collect(),
180                    returns: m.returns.map(sym),
181                    own_records: usize::from(m.own_records),
182                    code: Rc::new(code(m.code, Vec::new(), Some(format!("{name}.{method}")))),
183                    name: method,
184                }
185            })
186            .collect();
187        let code = ClassCode { parent: sym(parent), factory: factory.map(part), object: object.map(part), methods };
188        let sources = program.debug.sources.iter().map(|&s| sym(s)).collect();
189        Ok(FoundClass { code: Rc::new(code), sources })
190    }
191}
192
193impl Read {
194    /// The lowest ordinal not yet taken whose directory entry `wanted` accepts.
195    fn untaken(&self, wanted: impl Fn(&DirectoryEntry) -> bool) -> Option<usize> {
196        self.directory.iter().zip(&self.programs).position(|(e, p)| p.is_some() && wanted(e))
197    }
198
199    fn defining(&self, external: &str) -> Option<usize> {
200        self.programs.iter().position(|p| p.as_ref().is_some_and(|p| defines(p, external)))
201    }
202}
203
204fn defines(program: &Program, external: &str) -> bool {
205    program.services.class.as_ref().is_some_and(|c| symbol(program, c.external) == external)
206}
207
208fn symbol(program: &Program, id: SymId) -> String {
209    program.symbols.get(id as usize).cloned().unwrap_or_default()
210}
211
212/// A program from a module as the VM holds it, with the PROGRAM-IDs of the programs it directly
213/// contains and, for a method, the `Class.method` a dump lists it by.
214fn code(program: Program, nested: Vec<String>, method: Option<String>) -> Code {
215    let entries = program.services.entries.iter().map(|e| symbol(&program, e.name)).collect();
216    let (files, size) = (program.services.files.len(), program.storage.size as usize);
217    Code::new(Ok(program), entries, files, size, nested, method)
218}
219
220/// The module at `path`, read and checked, or why not with the path in front.
221fn open(path: &Path) -> Result<LoadedModule, String> {
222    let bytes = std::fs::read(path).map_err(|e| format!("{}: {e}", path.display()))?;
223    read(&bytes).map_err(|e| format!("{}: {e}", path.display()))
224}
ironwork_rt/module/library.rs

ironwork_rt/module/
library.rs
