tectonic_engine_bibtex 0.2.0

The `bibtex` program as a reusable crate.
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

use crate::c_api::{cite::with_cites, xbuf::XBuf, ASCIICode};
use std::cell::RefCell;

pub const ENT_STR_SIZE: usize = 250;

pub struct EntryData {
    num_entry_ints: usize,
    num_entry_strs: usize,
    sort_key_num: usize,
    entry_ints: Option<XBuf<i32>>,
    entry_strs: Option<XBuf<ASCIICode>>,
}

impl EntryData {
    fn new() -> EntryData {
        EntryData {
            num_entry_ints: 0,
            num_entry_strs: 0,
            sort_key_num: 0,
            entry_ints: None,
            entry_strs: None,
        }
    }

    pub fn strs(&self, pos: usize) -> ASCIICode {
        self.entry_strs.as_ref().unwrap()[pos]
    }

    pub fn num_ent_strs(&self) -> usize {
        self.num_entry_strs
    }

    pub fn set_num_ent_strs(&mut self, val: usize) {
        self.num_entry_strs = val;
    }

    pub fn sort_key_num(&self) -> usize {
        self.sort_key_num
    }

    pub fn set_sort_key_num(&mut self, val: usize) {
        self.sort_key_num = val;
    }
}

thread_local! {
    pub static ENTRIES: RefCell<EntryData> = RefCell::new(EntryData::new());
}

pub fn reset() {
    ENTRIES.with(|entries| *entries.borrow_mut() = EntryData::new());
}

pub fn with_entries<T>(f: impl FnOnce(&EntryData) -> T) -> T {
    ENTRIES.with(|entries| f(&entries.borrow()))
}

pub fn with_entries_mut<T>(f: impl FnOnce(&mut EntryData) -> T) -> T {
    ENTRIES.with(|entries| f(&mut entries.borrow_mut()))
}

#[no_mangle]
pub extern "C" fn init_entry_ints() {
    with_entries_mut(|entries| {
        let num_cites = with_cites(|cites| cites.num_cites());
        entries.entry_ints = Some(XBuf::new((entries.num_entry_ints + 1) * (num_cites + 1)));
    })
}

#[no_mangle]
pub extern "C" fn init_entry_strs() {
    with_entries_mut(|entries| {
        let num_cites = with_cites(|cites| cites.num_cites());
        let mut new_buf =
            XBuf::new((entries.num_entry_strs + 1) * (num_cites + 1) * (ENT_STR_SIZE + 1));
        new_buf.fill(127);
        entries.entry_strs = Some(new_buf);
    })
}

#[no_mangle]
pub extern "C" fn num_ent_ints() -> usize {
    with_entries(|entries| entries.num_entry_ints)
}

#[no_mangle]
pub extern "C" fn set_num_ent_ints(val: usize) {
    with_entries_mut(|entries| entries.num_entry_ints = val)
}

#[no_mangle]
pub extern "C" fn num_ent_strs() -> usize {
    with_entries(|entries| entries.num_entry_strs)
}

#[no_mangle]
pub extern "C" fn set_num_ent_strs(val: usize) {
    with_entries_mut(|entries| entries.num_entry_strs = val)
}

#[no_mangle]
pub extern "C" fn entry_ints(pos: i32) -> i32 {
    with_entries(|entries| entries.entry_ints.as_ref().unwrap()[pos as usize])
}

#[no_mangle]
pub extern "C" fn set_entry_ints(pos: i32, val: i32) {
    with_entries_mut(|entries| entries.entry_ints.as_mut().unwrap()[pos as usize] = val)
}

#[no_mangle]
pub extern "C" fn entry_strs(pos: i32) -> ASCIICode {
    with_entries(|entries| entries.entry_strs.as_ref().unwrap()[pos as usize])
}

#[no_mangle]
pub extern "C" fn set_entry_strs(pos: i32, val: ASCIICode) {
    with_entries_mut(|entries| entries.entry_strs.as_mut().unwrap()[pos as usize] = val)
}