maxpre 0.1.0

Rust bindings for the (MO-)MaxSAT preprocessor MaxPre
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

#![allow(dead_code, unused)]
use glob::glob;
use std::{
    env,
    fs::{self, File},
    io::Write,
    path::Path,
    process::Command,
    str,
};

fn main() {
    build_maxpre(
        "https://bitbucket.org/coreo-group/maxpre2.git",
        "master",
        "7cd387d2b1ca1f72077b0dacd15321aea31ec77c",
    );

    let out_dir = env::var("OUT_DIR").unwrap();

    println!("cargo:rustc-link-search={}", out_dir);
}

fn build_maxpre(repo: &str, branch: &str, commit: &str) {
    let out_dir = env::var("OUT_DIR").unwrap();
    let mut maxpre_dir_str = out_dir.clone();
    maxpre_dir_str.push_str("/maxpre");
    let maxpre_dir = Path::new(&maxpre_dir_str);
    if update_repo(maxpre_dir, repo, branch, commit)
        || !Path::new(&out_dir).join("libmaxpre.a").exists()
    {
        // Repo changed, rebuild
        // We specify the build manually here instead of calling make for better portability
        let src_files = vec![
            "preprocessor.cpp",
            "preprocessedinstance.cpp",
            "trace.cpp",
            "utility.cpp",
            "probleminstance.cpp",
            "timer.cpp",
            "clause.cpp",
            "log.cpp",
            "AMSLEX.cpp",
            "touchedlist.cpp",
            "preprocessorinterface.cpp",
            "cardinalityconstraint.cpp",
            "satlikeinterface.cpp",
            "cpreprocessorinterface.cpp",
            "satsolver/solvers/glucose3/utils/System.cc",
            "satsolver/solvers/glucose3/core/Solver.cc",
        ]
        .into_iter()
        .map(|sf| maxpre_dir.join("src").join(sf));

        // Setup build
        let mut build = cc::Build::new();
        build.cpp(true);
        if env::var("PROFILE").unwrap() == "debug" {
            build
                .opt_level(0)
                .define("DEBUG", None)
                .warnings(true)
                .debug(true);
        } else {
            build.opt_level(3).define("NDEBUG", None).warnings(false);
        };

        // Build MaxPre
        build
            .include(maxpre_dir.join("src"))
            .define("GIT_IDENTIFIER", Some(&format!("\"{}\"", commit)[..]))
            .files(src_files)
            .compile("maxpre");
    };

    println!("cargo:rustc-link-lib=static=maxpre");

    #[cfg(target_os = "macos")]
    println!("cargo:rustc-flags=-l dylib=c++");

    #[cfg(not(target_os = "macos"))]
    println!("cargo:rustc-flags=-l dylib=stdc++");
}

/// Returns true if there were changes, false if not
fn update_repo(path: &Path, url: &str, branch: &str, commit: &str) -> bool {
    let mut changed = false;
    let target_oid = git2::Oid::from_str(commit)
        .unwrap_or_else(|e| panic!("Invalid commit hash {}: {}", commit, e));
    // Update repo
    let repo = match git2::Repository::open(path) {
        Ok(repo) => {
            // Check if already at correct commit
            if let Some(oid) = repo.head().unwrap().target_peel() {
                if oid == target_oid {
                    return changed;
                }
            };
            // Check if commit needs to be fetched
            if repo.find_commit(target_oid).is_err() {
                // Fetch repo
                let mut remote = repo.find_remote("origin").unwrap_or_else(|_| {
                    panic!("Expected remote \"origin\" in git repo {:?}", path)
                });
                remote
                    .fetch(&[branch], None, None)
                    .unwrap_or_else(|e| {
                        panic!(
                            "Could not fetch \"origin/{}\" for git repo {:?}: {}",
                            branch, path, e
                        )
                    });
                drop(remote);
            }
            repo
        }
        Err(_) => {
            if path.exists() {
                fs::remove_dir_all(path).unwrap_or_else(|e| {
                    panic!(
                        "Could not delete directory {}: {}",
                        path.to_str().unwrap(),
                        e
                    )
                });
            };
            changed = true;
            git2::Repository::clone(url, path)
                .unwrap_or_else(|e| panic!("Could not clone repository {}: {}", url, e))
        }
    };
    let target_commit = repo
        .find_commit(target_oid)
        .unwrap_or_else(|e| panic!("Could not find commit {}: {}", commit, e));
    repo.checkout_tree(target_commit.as_object(), None)
        .unwrap_or_else(|e| panic!("Could not checkout commit {}: {}", commit, e));
    repo.set_head_detached(target_oid)
        .unwrap_or_else(|e| panic!("Could not detach head at {}: {}", commit, e));
    changed
}