slinky 0.5.0

Linker script generator for decompilation and modding projects
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

/* SPDX-FileCopyrightText: © 2024-2026 decompals */
/* SPDX-License-Identifier: MIT */

use std::{fs, path::Path};

use serde::Deserialize;

use crate::{
    absent_nullable::AbsentNullable, assert_entry::AssertEntrySerial,
    required_symbol::RequiredSymbolSerial, segment::SegmentSerial, settings::SettingsSerial,
    symbol_assignment::SymbolAssignmentSerial, traits::Serial, vram_class::VramClassSerial,
    AssertEntry, KeepSections, RequiredSymbol, Segment, Settings, SlinkyError, SymbolAssignment,
    VramClass,
};

#[derive(Debug, PartialEq)]
#[non_exhaustive]
pub struct Document {
    pub settings: Settings,

    pub vram_classes: Vec<VramClass>,

    pub segments: Vec<Segment>,

    pub entry: Option<String>,
    pub symbol_assignments: Vec<SymbolAssignment>,
    pub required_symbols: Vec<RequiredSymbol>,
    pub asserts: Vec<AssertEntry>,
}

impl Document {
    pub fn read_file(path: &Path) -> Result<Self, SlinkyError> {
        let f = match fs::File::open(path) {
            Ok(f) => f,
            Err(e) => {
                return Err(SlinkyError::FailedFileOpen {
                    path: path.to_path_buf(),
                    description: e.to_string(),
                })
            }
        };
        let document_serial: DocumentSerial = match serde_yaml::from_reader(f) {
            Ok(d) => d,
            Err(e) => {
                return Err(SlinkyError::FailedYamlParsing {
                    description: e.to_string(),
                })
            }
        };

        document_serial.unserialize()
    }
}

#[derive(Debug, PartialEq, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct DocumentSerial {
    #[serde(default)]
    pub settings: AbsentNullable<SettingsSerial>,

    #[serde(default)]
    pub vram_classes: AbsentNullable<Vec<VramClassSerial>>,

    pub segments: Vec<SegmentSerial>,

    #[serde(default)]
    pub entry: AbsentNullable<String>,
    #[serde(default)]
    pub symbol_assignments: AbsentNullable<Vec<SymbolAssignmentSerial>>,
    #[serde(default)]
    pub required_symbols: AbsentNullable<Vec<RequiredSymbolSerial>>,
    #[serde(default)]
    pub asserts: AbsentNullable<Vec<AssertEntrySerial>>,
}

impl DocumentSerial {
    pub fn unserialize(self) -> Result<Document, SlinkyError> {
        let settings = match self.settings.get_non_null_no_default("settings")? {
            None => Settings::default(),
            Some(v) => v.unserialize()?,
        };

        if self.segments.is_empty() {
            return Err(SlinkyError::EmptyValue {
                name: "segments".to_string(),
            });
        }

        let vram_classes = self
            .vram_classes
            .get_non_null("vram_classes", Vec::new)?
            .unserialize(&settings)?;

        let mut segments = self.segments.unserialize(&settings)?;

        let entry = self.entry.get_non_null_no_default("entry")?;

        let symbol_assignments = self
            .symbol_assignments
            .get_non_null("symbol_assignments", Vec::new)?
            .unserialize(&settings)?;

        let required_symbols = self
            .required_symbols
            .get_non_null("required_symbols", Vec::new)?
            .unserialize(&settings)?;

        let asserts = self
            .asserts
            .get_non_null("asserts", Vec::new)?
            .unserialize(&settings)?;

        for segment in segments.iter_mut() {
            if let Some(vram_class_name) = &segment.vram_class {
                if let Some(vram_class) = vram_classes.iter().find(|x| x.name == *vram_class_name) {
                    if vram_class.keep_sections != KeepSections::Absent {
                        segment.pass_down_keep_sections(&vram_class.keep_sections);
                    }
                }
            }
        }

        Ok(Document {
            settings,
            vram_classes,
            segments,
            entry,
            symbol_assignments,
            required_symbols,
            asserts,
        })
    }
}