ironwork-compile 0.7.0

ironwork for COBOL: the compiler that checks a parsed program and lays out its storage as IBM does
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

//! EXTERNAL and GLOBAL (Language Reference SC27-8713-03, pp. 63-66, 184-185, 197): where each may
//! be written, and what a contained program sees of the programs containing it. A GLOBAL record,
//! and an EXTERNAL one, is laid out as a LINKAGE record whose address the run unit gives it; see
//! [`Binding`]. Assumptions C180 and C181 hold what the manuals leave open.

use crate::layout::{Binding, Layout, Resolved, Section};
use syntax::ast::*;
use syntax::Error;

/// The GLOBAL records and files of the programs containing a program, as it compiles them.
#[derive(Default)]
pub(crate) struct Inherited {
    /// Their entries, laid out after the program's own LINKAGE records.
    pub entries: Vec<DataEntry>,
    /// For each of their 01 records, in order, where it is, the declaring program's depth, and
    /// for a file's record the file among the program's own.
    records: Vec<(Binding, u8, Option<usize>)>,
}

/// The rules for EXTERNAL and GLOBAL in a program's own DATA DIVISION.
pub(crate) fn rules(program: &Program, errors: &mut Vec<Error>) {
    let contains = !program.nested.is_empty();
    let sections: [(&str, &[DataEntry]); 3] = [("WORKING-STORAGE", &program.working_storage), ("LOCAL-STORAGE", &program.local_storage), ("LINKAGE", &program.linkage)];
    let mut externals: Vec<&str> = Vec::new();
    let mut globals: Vec<&str> = Vec::new();
    for (section, entries) in sections {
        let mut record: Option<&DataEntry> = None;
        for e in entries {
            if matches!(e.level, 1 | 77) {
                record = Some(e);
            }
            let name = e.name.as_deref().unwrap_or("FILLER");
            if e.external {
                if section != "WORKING-STORAGE" {
                    errors.push(Error::at(e.pos, format!("{name}: EXTERNAL is not allowed in the {section} SECTION")));
                } else if e.level != 1 {
                    errors.push(Error::at(e.pos, format!("{name}: EXTERNAL goes on a level-01 entry")));
                } else if e.redefines.is_some() {
                    errors.push(Error::at(e.pos, format!("{name}: EXTERNAL and REDEFINES cannot be in the same entry")));
                } else if e.name.is_none() {
                    errors.push(Error::at(e.pos, "an EXTERNAL record needs a data-name, not FILLER"));
                } else if externals.contains(&name) {
                    errors.push(Error::at(e.pos, format!("{name}: another EXTERNAL record of the program has the same name")));
                } else {
                    externals.push(name);
                }
            }
            if e.global {
                if e.level != 1 {
                    errors.push(Error::at(e.pos, format!("{name}: GLOBAL goes on a level-01 entry")));
                } else if e.name.is_none() {
                    errors.push(Error::at(e.pos, "a GLOBAL record needs a data-name, not FILLER"));
                } else if globals.contains(&name) {
                    errors.push(Error::at(e.pos, format!("{name}: another GLOBAL record of the DATA DIVISION has the same name")));
                } else {
                    globals.push(name);
                }
            }
            if let Some(r) = record.filter(|r| r.external && e.level != 88 && e.value.is_some()) {
                errors.push(Error::at(e.pos, format!("{name}: an item of EXTERNAL record {} takes no VALUE clause", r.name.as_deref().unwrap_or_default())));
            }
            if contains && !e.indexed_by.is_empty() && record.is_some_and(|r| r.global) {
                errors.push(Error::at(e.pos, format!("{name}: INDEXED BY in a GLOBAL record, in a program that contains others, is not supported yet")));
            }
        }
    }
    for f in &program.files {
        if (f.external || f.global) && f.records.iter().any(|e| e.level == 1 && e.name.is_none()) {
            errors.push(Error::at(f.pos, format!("FD {}: a record of an EXTERNAL or GLOBAL file needs a data-name, not FILLER", f.name)));
        }
        if f.external && f.linage.is_some() {
            errors.push(Error::at(f.pos, format!("FD {}: LINAGE on an EXTERNAL file is not supported yet", f.name)));
        }
        if f.external && !f.reports.is_empty() {
            errors.push(Error::at(f.pos, format!("FD {}: REPORT on an EXTERNAL file is not supported yet", f.name)));
        }
        if contains && f.global && (f.linage.is_some() || !f.reports.is_empty()) {
            errors.push(Error::at(f.pos, format!("FD {}: LINAGE or REPORT on a GLOBAL file, in a program that contains others, is not supported yet", f.name)));
        }
        if contains && !f.global && let Some(e) = f.records.iter().find(|e| e.global) {
            errors.push(Error::at(e.pos, format!("{}: a GLOBAL record of FD {}, which is not GLOBAL, in a program that contains others, is not supported yet", e.name.as_deref().unwrap_or("FILLER"), f.name)));
        }
    }
}

/// Takes in the GLOBAL records and files of the programs containing `program`, innermost first; a
/// file-name the program or a nearer program declares hides a farther one (pp. 66, 556 of the
/// Programming Guide SC27-8714-03). Their files join the program's own, after them.
pub(crate) fn inherit(program: &mut Program) -> Inherited {
    let mut inherited = Inherited::default();
    let containers = std::mem::take(&mut program.containers);
    for (n, c) in containers.iter().enumerate() {
        let depth = u8::try_from(n + 1).unwrap_or(u8::MAX);
        let sections = [(Section::WorkingStorage, &c.working_storage), (Section::LocalStorage, &c.local_storage), (Section::Linkage, &c.linkage)];
        for (section, entries) in sections {
            for e in entries {
                if matches!(e.level, 1 | 77) {
                    let record = e.name.clone().unwrap_or_default();
                    let binding = if e.external { Binding::External { name: record, size: 0 } } else { Binding::Global { program: c.id.clone(), record, section: section.clone() } };
                    inherited.records.push((binding, depth, None));
                }
                inherited.entries.push(e.clone());
            }
        }
        for f in &c.files {
            if program.files.iter().any(|own| own.name == f.name) {
                continue;
            }
            let k = program.files.len();
            let mut copy = f.clone();
            copy.declared_in = Some(c.id.clone());
            copy.linage = None;
            copy.reports.clear();
            for e in std::mem::take(&mut copy.records) {
                if matches!(e.level, 1 | 77) {
                    let binding = if f.external { Binding::ExternalFile(k as u16) } else { Binding::Global { program: c.id.clone(), record: String::new(), section: Section::File(f.name.clone()) } };
                    inherited.records.push((binding, depth, Some(k)));
                }
                inherited.entries.push(e);
            }
            program.files.push(copy);
        }
    }
    program.containers = containers;
    inherited
}

/// Gives the inherited records, which follow the program's `own` LINKAGE records, their places,
/// and an inherited file its record area.
pub(crate) fn bind(layout: &mut Layout, own: usize, inherited: Inherited, files: &[FileDecl]) {
    for (n, (binding, depth, file)) in inherited.records.into_iter().enumerate() {
        let ordinal = own + n;
        let Some(&root) = layout.linkage_roots.get(ordinal) else { continue };
        let size = layout.items[root].size;
        layout.bindings[ordinal] = match binding {
            Binding::External { name, .. } => Binding::External { name, size },
            other => other,
        };
        layout.depths[ordinal] = depth;
        let Some(k) = file else { continue };
        for i in 0..layout.items.len() {
            if layout.items[i].linkage == Some(ordinal as u16) {
                layout.items[i].file = Some(k as u16);
            }
        }
        layout.bound_areas[k].get_or_insert(ordinal as u16);
        let area = layout.file_areas[k].1.max(size).max(files[k].record_max.unwrap_or(0));
        layout.file_areas[k] = (0, area);
    }
}

/// The rules that need the layout: a record redefining an EXTERNAL one is no larger (p. 226), and
/// a GLOBAL file's FILE STATUS and keys, which the declaring program resolves, are its GLOBAL
/// names.
pub(crate) fn check(program: &Program, layout: &Layout, errors: &mut Vec<Error>) {
    for (&root, binding) in layout.linkage_roots.iter().zip(&layout.bindings) {
        let item = &layout.items[root];
        if let Binding::External { name, size } = binding
            && item.redefines.is_some()
            && item.size > *size
        {
            errors.push(Error::at(item.pos, format!("{}: {} bytes, larger than the EXTERNAL record {name} it redefines", item.name.as_deref().unwrap_or_default(), item.size)));
        }
    }
    for f in &program.files {
        let Some(declarer) = &f.declared_in else { continue };
        let refs = f.status.iter().map(|r| ("FILE STATUS", r)).chain(f.record_key.iter().map(|r| ("RECORD KEY", r))).chain(f.alternate_keys.iter().map(|(r, _)| ("ALTERNATE RECORD KEY", r))).chain(f.relative_key.iter().map(|r| ("RELATIVE KEY", r)));
        for (clause, r) in refs {
            if !declared_by(layout, r, declarer) {
                errors.push(Error::at(r.pos, format!("{}, a GLOBAL file of {declarer}: its {clause} {} is not a GLOBAL name of {declarer}, which is not supported yet", f.name, r.name)));
            }
        }
    }
}

fn declared_by(layout: &Layout, r: &Ref, program: &str) -> bool {
    let Ok(Resolved::Item(mut i)) = layout.resolve(&r.name, &r.qualifiers, r.pos) else { return false };
    while let Some(p) = layout.items[i].parent {
        i = p;
    }
    let binding = layout.items[i].linkage.and_then(|l| layout.bindings.get(l as usize));
    matches!(binding, Some(Binding::Global { program: p, .. }) if p == program)
}

/// SET ADDRESS OF gives an address to a LINKAGE record only, not to one the run unit places.
pub(crate) fn set_address(layout: &Layout, r: &Ref, errors: &mut Vec<Error>) {
    let Ok(Resolved::Item(i)) = layout.resolve(&r.name, &r.qualifiers, r.pos) else { return };
    let Some(l) = layout.items[i].linkage.filter(|_| layout.items[i].parent.is_none()) else { return };
    match &layout.bindings[l as usize] {
        Binding::Argument => {}
        Binding::Global { section: Section::Linkage, program, .. } => {
            errors.push(Error::at(r.pos, format!("SET ADDRESS OF {}, a GLOBAL LINKAGE record of {program}, in a program it contains is not supported yet", r.name)));
        }
        _ => errors.push(Error::at(r.pos, format!("SET ADDRESS OF {}: an EXTERNAL or GLOBAL record is not a LINKAGE record of the program", r.name))),
    }
}

/// How many LINKAGE records the program declares itself: its 01 and 77 entries there.
pub(crate) fn own_linkage(program: &Program) -> usize {
    program.linkage.iter().filter(|e| matches!(e.level, 1 | 77)).count()
}