OLD | NEW |
1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "vm/bootstrap_natives.h" | 5 #include "vm/bootstrap_natives.h" |
6 | 6 |
7 #include "vm/exceptions.h" | 7 #include "vm/exceptions.h" |
8 #include "vm/native_entry.h" | 8 #include "vm/native_entry.h" |
9 #include "vm/object.h" | 9 #include "vm/object.h" |
10 | 10 |
11 namespace dart { | 11 namespace dart { |
12 | 12 |
13 DEFINE_NATIVE_ENTRY(StringBase_createFromCodePoints, 1) { | 13 DEFINE_NATIVE_ENTRY(StringBase_createFromCodePoints, 1) { |
14 const Array& a = Array::CheckedHandle(arguments->At(0)); | 14 GET_NATIVE_ARGUMENT(Array, a, arguments->At(0)); |
15 // TODO(srdjan): Check that parameterized type is an int. | 15 // TODO(srdjan): Check that parameterized type is an int. |
16 Zone* zone = Isolate::Current()->current_zone(); | 16 Zone* zone = Isolate::Current()->current_zone(); |
17 intptr_t len = a.Length(); | 17 intptr_t len = a.Length(); |
18 | 18 |
19 // Unbox the array and determine the maximum element width. | 19 // Unbox the array and determine the maximum element width. |
20 bool is_one_byte_string = true; | 20 bool is_one_byte_string = true; |
21 bool is_two_byte_string = true; | 21 bool is_two_byte_string = true; |
22 uint32_t* temp = reinterpret_cast<uint32_t*>( | 22 uint32_t* temp = reinterpret_cast<uint32_t*>( |
23 zone->Allocate(len * sizeof(uint32_t))); // NOLINT | 23 zone->Allocate(len * sizeof(uint32_t))); // NOLINT |
24 Smi& element = Smi::Handle(); | 24 Smi& element = Smi::Handle(); |
(...skipping 23 matching lines...) Expand all Loading... |
48 } else if (is_two_byte_string) { | 48 } else if (is_two_byte_string) { |
49 result ^= TwoByteString::New(temp, len, Heap::kNew); | 49 result ^= TwoByteString::New(temp, len, Heap::kNew); |
50 } else { | 50 } else { |
51 result ^= FourByteString::New(temp, len, Heap::kNew); | 51 result ^= FourByteString::New(temp, len, Heap::kNew); |
52 } | 52 } |
53 arguments->SetReturn(result); | 53 arguments->SetReturn(result); |
54 } | 54 } |
55 | 55 |
56 | 56 |
57 DEFINE_NATIVE_ENTRY(String_hashCode, 1) { | 57 DEFINE_NATIVE_ENTRY(String_hashCode, 1) { |
58 const String& str = String::CheckedHandle(arguments->At(0)); | 58 const String& receiver = String::CheckedHandle(arguments->At(0)); |
59 intptr_t hash_val = 0; | 59 intptr_t hash_val = receiver.Hash(); |
60 if (!str.IsNull()) { | 60 ASSERT(hash_val > 0); |
61 hash_val = str.Hash(); | |
62 } | |
63 ASSERT(Smi::IsValid(hash_val)); | 61 ASSERT(Smi::IsValid(hash_val)); |
64 ASSERT(hash_val > 0); | |
65 const Smi& hash_smi = Smi::Handle(Smi::New(hash_val)); | 62 const Smi& hash_smi = Smi::Handle(Smi::New(hash_val)); |
66 arguments->SetReturn(hash_smi); | 63 arguments->SetReturn(hash_smi); |
67 } | 64 } |
68 | 65 |
69 | 66 |
70 DEFINE_NATIVE_ENTRY(String_getLength, 1) { | 67 DEFINE_NATIVE_ENTRY(String_getLength, 1) { |
71 const String& str = String::CheckedHandle(arguments->At(0)); | 68 const String& receiver = String::CheckedHandle(arguments->At(0)); |
72 arguments->SetReturn(Smi::Handle(Smi::New(str.Length()))); | 69 arguments->SetReturn(Smi::Handle(Smi::New(receiver.Length()))); |
73 } | 70 } |
74 | 71 |
75 | 72 |
76 static int32_t StringValueAt(const String& str, const Integer& index) { | 73 static int32_t StringValueAt(const String& str, const Integer& index) { |
77 if (index.IsSmi()) { | 74 if (index.IsSmi()) { |
78 Smi& smi = Smi::Handle(); | 75 Smi& smi = Smi::Handle(); |
79 smi ^= index.raw(); | 76 smi ^= index.raw(); |
80 int32_t index = smi.Value(); | 77 int32_t index = smi.Value(); |
81 if ((index < 0) || (index >= str.Length())) { | 78 if ((index < 0) || (index >= str.Length())) { |
82 GrowableArray<const Object*> arguments; | 79 GrowableArray<const Object*> arguments; |
83 arguments.Add(&smi); | 80 arguments.Add(&smi); |
84 Exceptions::ThrowByType(Exceptions::kIndexOutOfRange, arguments); | 81 Exceptions::ThrowByType(Exceptions::kIndexOutOfRange, arguments); |
85 } | 82 } |
86 return str.CharAt(index); | 83 return str.CharAt(index); |
87 } else { | 84 } else { |
88 // An index larger than Smi is always illegal. | 85 // An index larger than Smi is always illegal. |
89 GrowableArray<const Object*> arguments; | 86 GrowableArray<const Object*> arguments; |
90 arguments.Add(&index); | 87 arguments.Add(&index); |
91 Exceptions::ThrowByType(Exceptions::kIndexOutOfRange, arguments); | 88 Exceptions::ThrowByType(Exceptions::kIndexOutOfRange, arguments); |
92 return 0; | 89 return 0; |
93 } | 90 } |
94 } | 91 } |
95 | 92 |
96 | 93 |
97 DEFINE_NATIVE_ENTRY(String_charAt, 2) { | 94 DEFINE_NATIVE_ENTRY(String_charAt, 2) { |
98 const String& str = String::CheckedHandle(arguments->At(0)); | 95 const String& receiver = String::CheckedHandle(arguments->At(0)); |
99 GET_NATIVE_ARGUMENT(Integer, index, arguments->At(1)); | 96 GET_NATIVE_ARGUMENT(Integer, index, arguments->At(1)); |
100 uint32_t value = StringValueAt(str, index); | 97 uint32_t value = StringValueAt(receiver, index); |
101 ASSERT(value <= 0x10FFFF); | 98 ASSERT(value <= 0x10FFFF); |
102 arguments->SetReturn(String::Handle(String::NewSymbol(&value, 1))); | 99 arguments->SetReturn(String::Handle(String::NewSymbol(&value, 1))); |
103 } | 100 } |
104 | 101 |
105 DEFINE_NATIVE_ENTRY(String_charCodeAt, 2) { | 102 DEFINE_NATIVE_ENTRY(String_charCodeAt, 2) { |
106 const String& str = String::CheckedHandle(arguments->At(0)); | 103 const String& receiver = String::CheckedHandle(arguments->At(0)); |
107 GET_NATIVE_ARGUMENT(Integer, index, arguments->At(1)); | 104 GET_NATIVE_ARGUMENT(Integer, index, arguments->At(1)); |
108 int32_t value = StringValueAt(str, index); | 105 int32_t value = StringValueAt(receiver, index); |
109 ASSERT(value >= 0); | 106 ASSERT(value >= 0); |
110 ASSERT(value <= 0x10FFFF); | 107 ASSERT(value <= 0x10FFFF); |
111 arguments->SetReturn(Smi::Handle(Smi::New(value))); | 108 arguments->SetReturn(Smi::Handle(Smi::New(value))); |
112 } | 109 } |
113 | 110 |
114 | 111 |
115 DEFINE_NATIVE_ENTRY(String_concat, 2) { | 112 DEFINE_NATIVE_ENTRY(String_concat, 2) { |
116 const String& a = String::CheckedHandle(arguments->At(0)); | 113 const String& receiver = String::CheckedHandle(arguments->At(0)); |
117 GET_NATIVE_ARGUMENT(String, b, arguments->At(1)); | 114 GET_NATIVE_ARGUMENT(String, b, arguments->At(1)); |
118 const String& result = String::Handle(String::Concat(a, b)); | 115 const String& result = String::Handle(String::Concat(receiver, b)); |
119 arguments->SetReturn(result); | 116 arguments->SetReturn(result); |
120 } | 117 } |
121 | 118 |
122 | 119 |
123 DEFINE_NATIVE_ENTRY(String_toLowerCase, 1) { | 120 DEFINE_NATIVE_ENTRY(String_toLowerCase, 1) { |
124 const String& str = String::CheckedHandle(arguments->At(0)); | 121 const String& receiver = String::CheckedHandle(arguments->At(0)); |
125 ASSERT(!str.IsNull()); | 122 ASSERT(!receiver.IsNull()); |
126 const String& result = String::Handle(String::ToLowerCase(str)); | 123 const String& result = String::Handle(String::ToLowerCase(receiver)); |
127 arguments->SetReturn(result); | 124 arguments->SetReturn(result); |
128 } | 125 } |
129 | 126 |
130 | 127 |
131 DEFINE_NATIVE_ENTRY(String_toUpperCase, 1) { | 128 DEFINE_NATIVE_ENTRY(String_toUpperCase, 1) { |
132 const String& str = String::CheckedHandle(arguments->At(0)); | 129 const String& receiver = String::CheckedHandle(arguments->At(0)); |
133 ASSERT(!str.IsNull()); | 130 ASSERT(!receiver.IsNull()); |
134 const String& result = String::Handle(String::ToUpperCase(str)); | 131 const String& result = String::Handle(String::ToUpperCase(receiver)); |
135 arguments->SetReturn(result); | 132 arguments->SetReturn(result); |
136 } | 133 } |
137 | 134 |
138 | 135 |
139 DEFINE_NATIVE_ENTRY(Strings_concatAll, 1) { | 136 DEFINE_NATIVE_ENTRY(Strings_concatAll, 1) { |
140 const Array& strings = Array::CheckedHandle(arguments->At(0)); | 137 GET_NATIVE_ARGUMENT(Array, strings, arguments->At(0)); |
141 ASSERT(!strings.IsNull()); | 138 ASSERT(!strings.IsNull()); |
142 // Check that the array contains strings. | 139 // Check that the array contains strings. |
143 Instance& elem = Instance::Handle(); | 140 Instance& elem = Instance::Handle(); |
144 for (intptr_t i = 0; i < strings.Length(); i++) { | 141 for (intptr_t i = 0; i < strings.Length(); i++) { |
145 elem ^= strings.At(i); | 142 elem ^= strings.At(i); |
146 if (elem.IsNull()) { | 143 if (elem.IsNull()) { |
147 GrowableArray<const Object*> args; | 144 GrowableArray<const Object*> args; |
148 Exceptions::ThrowByType(Exceptions::kNullPointer, args); | 145 Exceptions::ThrowByType(Exceptions::kNullPointer, args); |
149 } | 146 } |
150 if (!elem.IsString()) { | 147 if (!elem.IsString()) { |
151 GrowableArray<const Object*> args; | 148 GrowableArray<const Object*> args; |
152 args.Add(&elem); | 149 args.Add(&elem); |
153 Exceptions::ThrowByType(Exceptions::kIllegalArgument, args); | 150 Exceptions::ThrowByType(Exceptions::kIllegalArgument, args); |
154 } | 151 } |
155 } | 152 } |
156 const String& result = String::Handle(String::ConcatAll(strings)); | 153 const String& result = String::Handle(String::ConcatAll(strings)); |
157 arguments->SetReturn(result); | 154 arguments->SetReturn(result); |
158 } | 155 } |
159 | 156 |
160 } // namespace dart | 157 } // namespace dart |
OLD | NEW |