openjlc 2.23.7

Ultra-fast Gerber conversion tool.
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

/* src/validator.rs */

use crate::config::get_target_dir;
use crate::error::report_error;
use crate::log;
use std::fs;

const REQUIRED_FILES: &[&str] = &["PCB下单必读.txt", "header.yaml"];

const REQUIRED_PREFIXES: &[&str] = &[
    "Gerber_BoardOutlineLayer",
    "Gerber_TopLayer",
    "Gerber_TopSolderMaskLayer",
];

pub static mut LAYER_COUNT: u32 = 0;

pub fn validate_target_directory() -> bool {
    let target_dir = get_target_dir();
    if !target_dir.exists() {
        log::log(&format!(
            "! Target directory not found: '{}'",
            target_dir.display()
        ));
        report_error();
        return false;
    }

    let files: Vec<String> = match fs::read_dir(&target_dir) {
        Ok(entries) => entries
            .filter_map(|entry| {
                entry
                    .ok()
                    .map(|e| e.file_name().to_string_lossy().into_owned())
            })
            .collect(),
        Err(e) => {
            log::log(&format!("! Failed to read target directory: {}", e));
            report_error();
            return false;
        }
    };

    let mut missing_files = Vec::new();
    let mut has_top_copper = false;
    let mut has_bottom_copper = false;
    let mut inner_layer_count = 0;

    for &required in REQUIRED_FILES {
        if !files.iter().any(|f| f == required) {
            missing_files.push(format!("! Missing '{}'", required));
        }
    }

    for &prefix in REQUIRED_PREFIXES {
        if !files.iter().any(|f| f.starts_with(prefix)) {
            missing_files.push(format!("! Missing '{}.*'", prefix));
        }
    }

    for file in &files {
        if file.starts_with("Gerber_TopLayer") {
            has_top_copper = true;
            if !files
                .iter()
                .any(|f| f.starts_with("Gerber_TopSolderMaskLayer"))
            {
                log::log("! Missing Gerber_TopSolderMaskLayer");
            }
            if !files
                .iter()
                .any(|f| f.starts_with("Gerber_TopSilkscreenLayer"))
            {
                log::log("! Missing Gerber_TopSilkscreenLayer");
            }
            if !files
                .iter()
                .any(|f| f.starts_with("Gerber_TopPasteMaskLayer"))
            {
                log::log("! Missing Gerber_TopPasteMaskLayer, consider checking it");
            }
        }

        if file.starts_with("Gerber_BottomLayer") {
            has_bottom_copper = true;
            if !files
                .iter()
                .any(|f| f.starts_with("Gerber_BottomSolderMaskLayer"))
            {
                log::log("! Missing Gerber_BottomSolderMaskLayer");
            }
            if !files
                .iter()
                .any(|f| f.starts_with("Gerber_BottomSilkscreenLayer"))
            {
                log::log("! Missing Gerber_BottomSilkscreenLayer");
            }
            if !files
                .iter()
                .any(|f| f.starts_with("Gerber_BottomPasteMaskLayer"))
            {
                log::log("! Missing Gerber_BottomPasteMaskLayer, consider checking it");
            }
        }

        if file.starts_with("Gerber_InnerLayer") {
            inner_layer_count += 1;
        }
    }

    if has_top_copper && inner_layer_count >= 1 && !has_bottom_copper {
        log::log("! Missing Bottom Copper layer due to Top Copper and Inner Layer presence");
        report_error();
    }

    let mut layer_count = 0;
    if has_top_copper {
        layer_count += 1;
    }
    if has_bottom_copper {
        layer_count += 1;
    }
    layer_count += inner_layer_count;

    unsafe {
        LAYER_COUNT = layer_count;
    }

    if missing_files.is_empty() {
        //log::log("- Structure validation passed");
        true
    } else {
        for msg in missing_files {
            log::log(&msg);
        }
        report_error();
        false
    }
}