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
|
//: Extend 'new' to handle a unicode string literal argument.
:(scenario new_string)
def main [
1:address:array:character <- new [abc def]
2:character <- index *1:address:array:character, 5
]
# number code for 'e'
+mem: storing 101 in location 2
:(scenario new_string_handles_unicode)
def main [
1:address:array:character <- new [a«c]
2:number <- length *1:address:array:character
3:character <- index *1:address:array:character, 1
]
+mem: storing 3 in location 2
# unicode for '«'
+mem: storing 171 in location 3
:(before "End NEW Check Special-cases")
if (is_literal_string(inst.ingredients.at(0))) break;
:(before "Convert 'new' To 'allocate'")
if (inst.name == "new" && is_literal_string(inst.ingredients.at(0))) continue;
:(after "case NEW" following "Primitive Recipe Implementations")
if (is_literal_string(current_instruction().ingredients.at(0))) {
products.resize(1);
products.at(0).push_back(new_mu_string(current_instruction().ingredients.at(0).name));
trace(9999, "mem") << "new string alloc: " << products.at(0).at(0) << end();
break;
}
:(code)
int new_mu_string(const string& contents) {
// allocate an array just large enough for it
int string_length = unicode_length(contents);
//? Total_alloc += string_length+1;
//? Num_alloc++;
ensure_space(string_length+1); // don't forget the extra location for array size
// initialize string
int result = Current_routine->alloc;
// initialize refcount
put(Memory, Current_routine->alloc++, 0);
// store length
put(Memory, Current_routine->alloc++, string_length);
int curr = 0;
const char* raw_contents = contents.c_str();
for (int i = 0; i < string_length; ++i) {
uint32_t curr_character;
assert(curr < SIZE(contents));
tb_utf8_char_to_unicode(&curr_character, &raw_contents[curr]);
put(Memory, Current_routine->alloc, curr_character);
curr += tb_utf8_char_length(raw_contents[curr]);
++Current_routine->alloc;
}
// mu strings are not null-terminated in memory
return result;
}
//: stash recognizes strings
:(scenario stash_string)
def main [
1:address:array:character <- new [abc]
stash [foo:], 1:address:array:character
]
+app: foo: abc
:(before "End print Special-cases(r, data)")
if (is_mu_string(r)) {
assert(scalar(data));
return read_mu_string(data.at(0))+' ';
}
:(scenario unicode_string)
def main [
1:address:array:character <- new [♠]
stash [foo:], 1:address:array:character
]
+app: foo: ♠
:(scenario stash_space_after_string)
def main [
1:address:array:character <- new [abc]
stash 1:address:array:character, [foo]
]
+app: abc foo
//: Allocate more to routine when initializing a literal string
:(scenario new_string_overflow)
% Initial_memory_per_routine = 2;
def main [
1:address:number/raw <- new number:type
2:address:array:character/raw <- new [a] # not enough room in initial page, if you take the array size into account
]
+new: routine allocated memory from 1000 to 1002
+new: routine allocated memory from 1002 to 1004
//: helpers
:(code)
int unicode_length(const string& s) {
const char* in = s.c_str();
int result = 0;
int curr = 0;
while (curr < SIZE(s)) { // carefully bounds-check on the string
// before accessing its raw pointer
++result;
curr += tb_utf8_char_length(in[curr]);
}
return result;
}
string read_mu_string(int address) {
if (address == 0) return "";
address++; // skip refcount
int size = get_or_insert(Memory, address);
if (size == 0) return "";
ostringstream tmp;
for (int curr = address+1; curr <= address+size; ++curr) {
tmp << to_unicode(static_cast<uint32_t>(get_or_insert(Memory, curr)));
}
return tmp.str();
}
|