cxxbridge-cmd 1.0.194

C++ code generator for integrating `cxx` crate into a non-Cargo build.
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

use crate::gen::out::{Content, OutFile};
use std::collections::BTreeSet;

#[derive(Default)]
pub(crate) struct Pragma<'a> {
    pub gnu_diagnostic_ignore: BTreeSet<&'a str>,
    pub clang_diagnostic_ignore: BTreeSet<&'a str>,
    pub dollar_in_identifier: bool,
    pub mismatched_new_delete: bool,
    pub missing_declarations: bool,
    pub return_type_c_linkage: bool,
    pub begin: Content<'a>,
    pub end: Content<'a>,
}

impl<'a> Pragma<'a> {
    pub fn new() -> Self {
        Pragma::default()
    }
}

pub(super) fn write(out: &mut OutFile) {
    let Pragma {
        ref mut gnu_diagnostic_ignore,
        ref mut clang_diagnostic_ignore,
        dollar_in_identifier,
        mismatched_new_delete,
        missing_declarations,
        return_type_c_linkage,
        ref mut begin,
        ref mut end,
    } = out.pragma;

    if dollar_in_identifier {
        clang_diagnostic_ignore.insert("-Wdollar-in-identifier-extension");
    }
    if mismatched_new_delete {
        gnu_diagnostic_ignore.insert("-Wmismatched-new-delete");
    }
    if missing_declarations {
        gnu_diagnostic_ignore.insert("-Wmissing-declarations");
    }
    if return_type_c_linkage {
        clang_diagnostic_ignore.insert("-Wreturn-type-c-linkage");
    }
    let gnu_diagnostic_ignore = &*gnu_diagnostic_ignore;
    let clang_diagnostic_ignore = &*clang_diagnostic_ignore;

    if !gnu_diagnostic_ignore.is_empty() {
        writeln!(begin, "#ifdef __GNUC__");
        if out.header {
            writeln!(begin, "#pragma GCC diagnostic push");
        }
        for diag in gnu_diagnostic_ignore {
            writeln!(begin, "#pragma GCC diagnostic ignored \"{diag}\"");
        }
    }
    if !clang_diagnostic_ignore.is_empty() {
        writeln!(begin, "#ifdef __clang__");
        if out.header && gnu_diagnostic_ignore.is_empty() {
            writeln!(begin, "#pragma clang diagnostic push");
        }
        for diag in clang_diagnostic_ignore {
            writeln!(begin, "#pragma clang diagnostic ignored \"{diag}\"");
        }
        writeln!(begin, "#endif // __clang__");
    }
    if !gnu_diagnostic_ignore.is_empty() {
        writeln!(begin, "#endif // __GNUC__");
    }

    if out.header {
        if !gnu_diagnostic_ignore.is_empty() {
            writeln!(end, "#ifdef __GNUC__");
            writeln!(end, "#pragma GCC diagnostic pop");
            writeln!(end, "#endif // __GNUC__");
        } else if !clang_diagnostic_ignore.is_empty() {
            writeln!(end, "#ifdef __clang__");
            writeln!(end, "#pragma clang diagnostic pop");
            writeln!(end, "#endif // __clang__");
        }
    }
}