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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

extern crate libc;

use self::libc::{c_char, c_void};
use self::libc::{memcmp, strlen};
use containers::hashset::hash;
use containers::hashset::Equal;
use containers::hashset::Hash;
use memory::Page;
use std::mem::size_of;
use std::ptr;
use std::ptr::write;

#[derive(Copy, Clone)]
pub struct String {
    pub data: *const u8,
}

const PACKED_SIZE: usize = size_of::<usize>() * 8 / 7;

impl String {
    pub fn create(_rp: *mut Page, data: *const u8, length: usize) -> String {
        let mut length_array: [u8; PACKED_SIZE] = [0; PACKED_SIZE];
        let mut rest = length;
        let mut counter: usize = 0;
        while rest >= 0x80 {
            length_array[counter] = rest as u8 | 0x80;
            rest >>= 7;
            counter += 1;
        }
        length_array[counter] = rest as u8;
        let overall_length = counter + 1 + length;
        unsafe {
            let pointer = (*_rp).allocate_raw(overall_length, 1);
            ptr::copy_nonoverlapping(length_array.as_ptr(), pointer, counter + 1);
            ptr::copy_nonoverlapping(data, pointer.offset((counter + 1) as isize), length);
            String { data: pointer }
        }
    }

    pub fn new(_rp: *mut Page, string: &str) -> String {
        let length = string.len();
        String::create(_rp, string.as_ptr(), length)
    }

    pub fn copy(_rp: *mut Page, other: String) -> String {
        let mut length_array: [u8; PACKED_SIZE] = [0; PACKED_SIZE];
        let length = other.get_length();
        let mut rest = length;
        let mut counter: usize = 0;
        while rest >= 0x80 {
            length_array[counter] = rest as u8 | 0x80;
            rest >>= 7;
            counter += 1;
        }
        length_array[counter] = rest as u8;
        let overall_length = counter + 1 + length;
        unsafe {
            let pointer = (*_rp).allocate_raw(overall_length, 1);
            ptr::copy_nonoverlapping(length_array.as_ptr(), pointer, counter + 1);
            ptr::copy_nonoverlapping(other.data.offset((counter + 1) as isize), pointer.offset((counter + 1) as isize), length);
            String { data: pointer }
        }
    }

    pub fn from_c_string(_rp: *mut Page, c_string: *const c_char) -> String {
        unsafe {
            let length = strlen(c_string);
            String::create(_rp, c_string as *const u8, length)
        }
    }

    pub fn from_character(_rp: *mut Page, character: char) -> String {
        String::create(_rp, &character as *const char as *const u8, 1)
    }

    #[allow(unreachable_code)]
    pub fn to_c_string(&self) -> *const c_char {
        let mut length_pointer: *const u8 = self.data as *const u8;
        loop {
            unsafe {
                if (*length_pointer) < 127 {
                    length_pointer = length_pointer.offset(1);
                    return length_pointer as *const c_char;
                }
                length_pointer = length_pointer.offset(1);
            }
        }
        self.data as *const c_char
    }

    pub fn from_string_slice(_rp: *mut Page, s: &str) -> String {
        String::create(_rp, s.as_ptr() as *const u8, s.len())
    }

    pub fn append_character(&self, _rp: *mut Page, c: char) -> String {
        unsafe {
            let s = String::create(_rp, self.data, self.get_length() + 1);
            let data = s.data as *mut char;
            let char_pointer = data.offset((self.get_length() - 1) as isize);
            write(char_pointer, c);
            s
        }
    }

    pub fn get_length(&self) -> usize {
        let mut result: usize = 0;
        let mut bit_count = 0;
        let mut index = 0;
        loop {
            if bit_count == PACKED_SIZE * 7 {
                panic!("Bad string length.");
            }

            let byte: u8 = unsafe { *(self.data.offset(index)) };
            result |= ((byte & 0x7F) as usize) << bit_count;
            if (byte & 0x80) == 0 {
                break;
            }
            bit_count += 7;
            index += 1;
        }
        result
    }
}

impl Equal for String {
    fn equals(&self, other: &String) -> bool {
        let length = self.get_length();
        if length != other.get_length() {
            return false;
        }

        unsafe {
            memcmp(
                self.data as *const c_void,
                other.data as *const c_void,
                length,
            ) == 0
        }
    }
}

impl Hash for String {
    fn hash(&self) -> usize {
        hash(self.data, self.get_length())
    }
}

#[test]
fn test_string() {
    use memory::Heap;
    use memory::Page;
    use memory::StackBucket;
    let mut heap = Heap::create();
    let root_stack_bucket = StackBucket::create(&mut heap);
    {
        let root_page = Page::get(root_stack_bucket as usize);
        let string = String::new(root_page, "Hello world!");
        let length = string.get_length();
        assert_eq!(length, 12);
        let long_string = String::new(root_page, "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
        assert_eq!(long_string.get_length(), 130);
    }
}