OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file |
| 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. |
| 4 |
| 5 #include <map> |
| 6 #include <vector> |
| 7 |
| 8 #include "vm/flags.h" |
| 9 #include "vm/kernel.h" |
| 10 #include "vm/os.h" |
| 11 |
| 12 #if defined(DEBUG) |
| 13 #define TRACE_READ_OFFSET() do { \ |
| 14 if (FLAG_trace_kernel_binary) \ |
| 15 reader->DumpOffset(__PRETTY_FUNCTION__); \ |
| 16 } while (0) |
| 17 #define TRACE_WRITE_OFFSET() do { \ |
| 18 if (FLAG_trace_kernel_binary) \ |
| 19 writer->DumpOffset(__PRETTY_FUNCTION__); \ |
| 20 } while (0) |
| 21 #else |
| 22 #define TRACE_READ_OFFSET() |
| 23 #define TRACE_WRITE_OFFSET() |
| 24 #endif |
| 25 |
| 26 namespace dart { |
| 27 |
| 28 |
| 29 ByteWriter::~ByteWriter() {} |
| 30 |
| 31 |
| 32 namespace kernel { |
| 33 |
| 34 |
| 35 static const uint32_t kMagicProgramFile = 0x90ABCDEFu; |
| 36 |
| 37 |
| 38 // Keep in sync with package:dynamo/lib/binary/tag.dart |
| 39 enum Tag { |
| 40 kNothing = 0, |
| 41 kSomething = 1, |
| 42 |
| 43 kNormalClass = 2, |
| 44 kMixinClass = 3, |
| 45 |
| 46 kField = 4, |
| 47 kConstructor = 5, |
| 48 kProcedure = 6, |
| 49 |
| 50 kInvalidInitializer = 7, |
| 51 kFieldInitializer = 8, |
| 52 kSuperInitializer = 9, |
| 53 kRedirectingInitializer = 10, |
| 54 kLocalInitializer = 11, |
| 55 |
| 56 kDirectPropertyGet = 15, |
| 57 kDirectPropertySet = 16, |
| 58 kDirectMethodInvocation = 17, |
| 59 kConstStaticInvocation = 18, |
| 60 kInvalidExpression = 19, |
| 61 kVariableGet = 20, |
| 62 kVariableSet = 21, |
| 63 kPropertyGet = 22, |
| 64 kPropertySet = 23, |
| 65 kSuperPropertyGet = 24, |
| 66 kSuperPropertySet = 25, |
| 67 kStaticGet = 26, |
| 68 kStaticSet = 27, |
| 69 kMethodInvocation = 28, |
| 70 kSuperMethodInvocation = 29, |
| 71 kStaticInvocation = 30, |
| 72 kConstructorInvocation = 31, |
| 73 kConstConstructorInvocation = 32, |
| 74 kNot = 33, |
| 75 kLogicalExpression = 34, |
| 76 kConditionalExpression = 35, |
| 77 kStringConcatenation = 36, |
| 78 kIsExpression = 37, |
| 79 kAsExpression = 38, |
| 80 kStringLiteral = 39, |
| 81 kDoubleLiteral = 40, |
| 82 kTrueLiteral = 41, |
| 83 kFalseLiteral = 42, |
| 84 kNullLiteral = 43, |
| 85 kSymbolLiteral = 44, |
| 86 kTypeLiteral = 45, |
| 87 kThisExpression = 46, |
| 88 kRethrow = 47, |
| 89 kThrow = 48, |
| 90 kListLiteral = 49, |
| 91 kMapLiteral = 50, |
| 92 kAwaitExpression = 51, |
| 93 kFunctionExpression = 52, |
| 94 kLet = 53, |
| 95 kBlockExpression = 54, |
| 96 |
| 97 kPositiveIntLiteral = 55, |
| 98 kNegativeIntLiteral = 56, |
| 99 kBigIntLiteral = 57, |
| 100 kConstListLiteral = 58, |
| 101 kConstMapLiteral = 59, |
| 102 |
| 103 kInvalidStatement = 60, |
| 104 kExpressionStatement = 61, |
| 105 kBlock = 62, |
| 106 kEmptyStatement = 63, |
| 107 kAssertStatement = 64, |
| 108 kLabeledStatement = 65, |
| 109 kBreakStatement = 66, |
| 110 kWhileStatement = 67, |
| 111 kDoStatement = 68, |
| 112 kForStatement = 69, |
| 113 kForInStatement = 70, |
| 114 kSwitchStatement = 71, |
| 115 kContinueSwitchStatement = 72, |
| 116 kIfStatement = 73, |
| 117 kReturnStatement = 74, |
| 118 kTryCatch = 75, |
| 119 kTryFinally = 76, |
| 120 kYieldStatement = 77, |
| 121 kVariableDeclaration = 78, |
| 122 kFunctionDeclaration = 79, |
| 123 kAsyncForInStatement = 80, |
| 124 |
| 125 kInvalidType = 90, |
| 126 kDynamicType = 91, |
| 127 kVoidType = 92, |
| 128 kInterfaceType = 93, |
| 129 kFunctionType = 94, |
| 130 kTypeParameterType = 95, |
| 131 kSimpleInterfaceType = 96, |
| 132 kSimpleFunctionType = 97, |
| 133 |
| 134 kNullReference = 99, |
| 135 kNormalClassReference = 100, |
| 136 kMixinClassReference = 101, |
| 137 |
| 138 kLibraryFieldReference = 102, |
| 139 kClassFieldReference = 103, |
| 140 kClassConstructorReference = 104, |
| 141 kLibraryProcedureReference = 105, |
| 142 kClassProcedureReference = 106, |
| 143 |
| 144 kSpecializedTagHighBit = 0x80, // 10000000 |
| 145 kSpecializedTagMask = 0xF8, // 11111000 |
| 146 kSpecializedPayloadMask = 0x7, // 00000111 |
| 147 |
| 148 kSpecializedVariableGet = 128, |
| 149 kSpecializedVariableSet = 136, |
| 150 kSpecialIntLiteral = 144, |
| 151 }; |
| 152 |
| 153 |
| 154 static const int SpecializedIntLiteralBias = 3; |
| 155 |
| 156 |
| 157 template <typename T> |
| 158 class BlockStack { |
| 159 public: |
| 160 BlockStack() : current_count_(0) {} |
| 161 |
| 162 void EnterScope() { |
| 163 variable_count_.push_back(current_count_); |
| 164 current_count_ = 0; |
| 165 } |
| 166 |
| 167 void LeaveScope() { |
| 168 variables_.resize(variables_.size() - current_count_); |
| 169 current_count_ = variable_count_[variable_count_.size() - 1]; |
| 170 variable_count_.pop_back(); |
| 171 } |
| 172 |
| 173 T* Lookup(int index) { |
| 174 ASSERT(static_cast<unsigned>(index) < variables_.size()); |
| 175 return variables_[index]; |
| 176 } |
| 177 |
| 178 void Push(T* v) { |
| 179 variables_.push_back(v); |
| 180 current_count_++; |
| 181 } |
| 182 |
| 183 void Push(List<T>* decl) { |
| 184 for (int i = 0; i < decl->length(); i++) { |
| 185 variables_.push_back(decl[i]); |
| 186 current_count_++; |
| 187 } |
| 188 } |
| 189 |
| 190 void Pop(T* decl) { |
| 191 variables_.resize(variables_.size() - 1); |
| 192 current_count_--; |
| 193 } |
| 194 |
| 195 void Pop(List<T>* decl) { |
| 196 variables_.resize(variables_.size() - decl->length()); |
| 197 current_count_ -= decl->length(); |
| 198 } |
| 199 |
| 200 private: |
| 201 int current_count_; |
| 202 std::vector<T*> variables_; |
| 203 std::vector<int> variable_count_; |
| 204 }; |
| 205 |
| 206 |
| 207 template <typename T> |
| 208 class BlockMap { |
| 209 public: |
| 210 BlockMap() : current_count_(0), stack_height_(0) {} |
| 211 |
| 212 void EnterScope() { |
| 213 variable_count_.push_back(current_count_); |
| 214 current_count_ = 0; |
| 215 } |
| 216 |
| 217 void LeaveScope() { |
| 218 stack_height_ -= current_count_; |
| 219 current_count_ = variable_count_[variable_count_.size() - 1]; |
| 220 variable_count_.pop_back(); |
| 221 } |
| 222 |
| 223 int Lookup(T* object) { |
| 224 ASSERT(variables_.find(object) != variables_.end()); |
| 225 if (variables_.find(object) == variables_.end()) FATAL("lookup failure"); |
| 226 return variables_[object]; |
| 227 } |
| 228 |
| 229 void Push(T* v) { |
| 230 int index = stack_height_++; |
| 231 variables_[v] = index; |
| 232 current_count_++; |
| 233 } |
| 234 |
| 235 void Set(T* v, int index) { variables_[v] = index; } |
| 236 |
| 237 void Push(List<T>* decl) { |
| 238 for (int i = 0; i < decl->length(); i++) { |
| 239 Push(decl[i]); |
| 240 } |
| 241 } |
| 242 |
| 243 void Pop(T* v) { |
| 244 current_count_--; |
| 245 stack_height_--; |
| 246 } |
| 247 |
| 248 private: |
| 249 int current_count_; |
| 250 int stack_height_; |
| 251 std::map<T*, int> variables_; |
| 252 std::vector<int> variable_count_; |
| 253 }; |
| 254 |
| 255 |
| 256 template <typename T> |
| 257 class VariableScope { |
| 258 public: |
| 259 explicit VariableScope(T* builder) : builder_(builder) { |
| 260 builder_->variables().EnterScope(); |
| 261 } |
| 262 ~VariableScope() { builder_->variables().LeaveScope(); } |
| 263 |
| 264 private: |
| 265 T* builder_; |
| 266 }; |
| 267 |
| 268 |
| 269 template <typename T> |
| 270 class TypeParameterScope { |
| 271 public: |
| 272 explicit TypeParameterScope(T* builder) : builder_(builder) { |
| 273 builder_->type_parameters().EnterScope(); |
| 274 } |
| 275 ~TypeParameterScope() { builder_->type_parameters().LeaveScope(); } |
| 276 |
| 277 private: |
| 278 T* builder_; |
| 279 }; |
| 280 |
| 281 |
| 282 template <typename T> |
| 283 class SwitchCaseScope { |
| 284 public: |
| 285 explicit SwitchCaseScope(T* builder) : builder_(builder) { |
| 286 builder_->switch_cases().EnterScope(); |
| 287 } |
| 288 ~SwitchCaseScope() { builder_->switch_cases().LeaveScope(); } |
| 289 |
| 290 private: |
| 291 T* builder_; |
| 292 }; |
| 293 |
| 294 |
| 295 class ReaderHelper { |
| 296 public: |
| 297 ReaderHelper() : program_(NULL) {} |
| 298 ~ReaderHelper() {} |
| 299 |
| 300 Program* program() { return program_; } |
| 301 void set_program(Program* program) { program_ = program; } |
| 302 |
| 303 BlockStack<VariableDeclaration>& variables() { return scope_; } |
| 304 BlockStack<TypeParameter>& type_parameters() { return type_parameters_; } |
| 305 BlockStack<LabeledStatement>& lables() { return labels_; } |
| 306 BlockStack<SwitchCase>& switch_cases() { return switch_cases_; } |
| 307 |
| 308 private: |
| 309 Program* program_; |
| 310 BlockStack<VariableDeclaration> scope_; |
| 311 BlockStack<TypeParameter> type_parameters_; |
| 312 BlockStack<LabeledStatement> labels_; |
| 313 BlockStack<SwitchCase> switch_cases_; |
| 314 }; |
| 315 |
| 316 |
| 317 class Reader { |
| 318 public: |
| 319 Reader(const uint8_t* buffer, int64_t size) |
| 320 : buffer_(buffer), size_(size), offset_(0) {} |
| 321 |
| 322 uint32_t ReadUInt32() { |
| 323 ASSERT(offset_ + 4 <= size_); |
| 324 |
| 325 uint32_t value = (buffer_[offset_ + 0] << 24) | |
| 326 (buffer_[offset_ + 1] << 16) | |
| 327 (buffer_[offset_ + 2] << 8) | (buffer_[offset_ + 3] << 0); |
| 328 offset_ += 4; |
| 329 return value; |
| 330 } |
| 331 |
| 332 uint32_t ReadUInt() { |
| 333 ASSERT(offset_ + 1 <= size_); |
| 334 uint8_t byte0 = buffer_[offset_]; |
| 335 if ((byte0 & 0x80) == 0) { |
| 336 // 0... |
| 337 offset_++; |
| 338 return byte0; |
| 339 } else if ((byte0 & 0xc0) == 0x80) { |
| 340 // 10... |
| 341 ASSERT(offset_ + 2 <= size_); |
| 342 uint32_t value = ((byte0 & ~0x80) << 8) | (buffer_[offset_ + 1]); |
| 343 offset_ += 2; |
| 344 return value; |
| 345 } else { |
| 346 // 11... |
| 347 ASSERT(offset_ + 4 <= size_); |
| 348 uint32_t value = ((byte0 & ~0xc0) << 24) | (buffer_[offset_ + 1] << 16) | |
| 349 (buffer_[offset_ + 2] << 8) | |
| 350 (buffer_[offset_ + 3] << 0); |
| 351 offset_ += 4; |
| 352 return value; |
| 353 } |
| 354 } |
| 355 |
| 356 intptr_t ReadListLength() { return ReadUInt(); } |
| 357 |
| 358 uint8_t ReadByte() { return buffer_[offset_++]; } |
| 359 |
| 360 bool ReadBool() { return (ReadByte() & 1) == 1; } |
| 361 |
| 362 word ReadFlags() { return ReadByte(); } |
| 363 |
| 364 Tag ReadTag(uint8_t* payload = NULL) { |
| 365 uint8_t byte = ReadByte(); |
| 366 bool has_payload = (byte & kSpecializedTagHighBit) != 0; |
| 367 if (has_payload) { |
| 368 if (payload != NULL) { |
| 369 *payload = byte & kSpecializedPayloadMask; |
| 370 } |
| 371 return static_cast<Tag>(byte & kSpecializedTagMask); |
| 372 } else { |
| 373 return static_cast<Tag>(byte); |
| 374 } |
| 375 } |
| 376 |
| 377 const uint8_t* Consume(int count) { |
| 378 ASSERT(offset_ + count <= size_); |
| 379 const uint8_t* old = buffer_ + offset_; |
| 380 offset_ += count; |
| 381 return old; |
| 382 } |
| 383 |
| 384 void EnsureEnd() { |
| 385 if (offset_ != size_) { |
| 386 FATAL2( |
| 387 "Reading Kernel file: Expected to be at EOF " |
| 388 "(offset: %" Pd64 ", size: %" Pd64 ")", |
| 389 offset_, size_); |
| 390 } |
| 391 } |
| 392 |
| 393 void DumpOffset(const char* str) { |
| 394 OS::PrintErr("@%" Pd64 " %s\n", offset_, str); |
| 395 } |
| 396 |
| 397 template <typename T, typename RT> |
| 398 T* ReadOptional() { |
| 399 Tag tag = ReadTag(); |
| 400 if (tag == kNothing) { |
| 401 return NULL; |
| 402 } |
| 403 ASSERT(tag == kSomething); |
| 404 return RT::ReadFrom(this); |
| 405 } |
| 406 |
| 407 template <typename T> |
| 408 T* ReadOptional() { |
| 409 return ReadOptional<T, T>(); |
| 410 } |
| 411 |
| 412 ReaderHelper* helper() { return &builder_; } |
| 413 |
| 414 private: |
| 415 const uint8_t* buffer_; |
| 416 int64_t size_; |
| 417 int64_t offset_; |
| 418 ReaderHelper builder_; |
| 419 }; |
| 420 |
| 421 |
| 422 class WriterHelper { |
| 423 public: |
| 424 void SetProgram(Program* program) { |
| 425 program_ = program; |
| 426 for (int i = 0; i < program->libraries().length(); i++) { |
| 427 Library* lib = program->libraries()[i]; |
| 428 libraries_.Set(lib, i); |
| 429 |
| 430 for (int j = 0; j < lib->classes().length(); j++) { |
| 431 Class* klass = lib->classes()[j]; |
| 432 classes_.Set(klass, j); |
| 433 |
| 434 for (int k = 0; k < klass->fields().length(); k++) { |
| 435 Field* field = klass->fields()[k]; |
| 436 fields_.Set(field, k); |
| 437 } |
| 438 for (int k = 0; k < klass->constructors().length(); k++) { |
| 439 Constructor* constructor = klass->constructors()[k]; |
| 440 constructors_.Set(constructor, k); |
| 441 } |
| 442 for (int k = 0; k < klass->procedures().length(); k++) { |
| 443 Procedure* procedure = klass->procedures()[k]; |
| 444 procedures_.Set(procedure, k); |
| 445 } |
| 446 } |
| 447 |
| 448 for (int k = 0; k < lib->fields().length(); k++) { |
| 449 Field* field = lib->fields()[k]; |
| 450 fields_.Set(field, k); |
| 451 } |
| 452 |
| 453 for (int k = 0; k < lib->procedures().length(); k++) { |
| 454 Procedure* procedure = lib->procedures()[k]; |
| 455 procedures_.Set(procedure, k); |
| 456 } |
| 457 } |
| 458 } |
| 459 |
| 460 Program* program() { return program_; } |
| 461 |
| 462 BlockMap<String>& strings() { return strings_; } |
| 463 BlockMap<Library>& libraries() { return libraries_; } |
| 464 BlockMap<Class>& classes() { return classes_; } |
| 465 BlockMap<Field>& fields() { return fields_; } |
| 466 BlockMap<Procedure>& procedures() { return procedures_; } |
| 467 BlockMap<Constructor>& constructors() { return constructors_; } |
| 468 |
| 469 BlockMap<VariableDeclaration>& variables() { return scope_; } |
| 470 BlockMap<TypeParameter>& type_parameters() { return type_parameters_; } |
| 471 BlockMap<LabeledStatement>& lables() { return labels_; } |
| 472 BlockMap<SwitchCase>& switch_cases() { return switch_cases_; } |
| 473 |
| 474 private: |
| 475 Program* program_; |
| 476 |
| 477 BlockMap<String> strings_; |
| 478 BlockMap<Library> libraries_; |
| 479 BlockMap<Class> classes_; |
| 480 BlockMap<Field> fields_; |
| 481 BlockMap<Procedure> procedures_; |
| 482 BlockMap<Constructor> constructors_; |
| 483 |
| 484 BlockMap<VariableDeclaration> scope_; |
| 485 BlockMap<TypeParameter> type_parameters_; |
| 486 BlockMap<LabeledStatement> labels_; |
| 487 BlockMap<SwitchCase> switch_cases_; |
| 488 }; |
| 489 |
| 490 |
| 491 class Writer { |
| 492 public: |
| 493 explicit Writer(ByteWriter* writer) : out_(writer), offset_(0) {} |
| 494 |
| 495 void WriteUInt32(uint32_t value) { |
| 496 uint8_t buffer[4] = { |
| 497 static_cast<uint8_t>((value >> 24) & 0xff), |
| 498 static_cast<uint8_t>((value >> 16) & 0xff), |
| 499 static_cast<uint8_t>((value >> 8) & 0xff), |
| 500 static_cast<uint8_t>((value >> 0) & 0xff), |
| 501 }; |
| 502 WriteBytes(buffer, 4); |
| 503 } |
| 504 |
| 505 void WriteUInt(uint32_t value) { |
| 506 if (value < 0x80) { |
| 507 // 0... |
| 508 WriteByte(static_cast<uint8_t>(value)); |
| 509 } else if (value < 0x4000) { |
| 510 // 10... |
| 511 WriteByte(static_cast<uint8_t>(((value >> 8) & 0x3f) | 0x80)); |
| 512 WriteByte(static_cast<uint8_t>(value & 0xff)); |
| 513 } else { |
| 514 // 11... |
| 515 // Ensure the highest 2 bits is not used for anything (we use it to for |
| 516 // encoding). |
| 517 ASSERT(static_cast<uint8_t>((value >> 24) & 0xc0) == 0); |
| 518 uint8_t buffer[4] = { |
| 519 static_cast<uint8_t>(((value >> 24) & 0x7f) | 0xc0), |
| 520 static_cast<uint8_t>((value >> 16) & 0xff), |
| 521 static_cast<uint8_t>((value >> 8) & 0xff), |
| 522 static_cast<uint8_t>((value >> 0) & 0xff), |
| 523 }; |
| 524 WriteBytes(buffer, 4); |
| 525 } |
| 526 } |
| 527 |
| 528 void WriteListLength(intptr_t value) { return WriteUInt(value); } |
| 529 |
| 530 void WriteByte(uint8_t value) { |
| 531 out_->WriteByte(value); |
| 532 offset_++; |
| 533 } |
| 534 |
| 535 void WriteBool(bool value) { WriteByte(value ? 1 : 0); } |
| 536 |
| 537 void WriteFlags(uint8_t value) { WriteByte(value); } |
| 538 |
| 539 void WriteTag(Tag tag) { WriteByte(static_cast<uint8_t>(tag)); } |
| 540 |
| 541 void WriteTag(Tag tag, uint8_t payload) { |
| 542 ASSERT((payload & ~kSpecializedPayloadMask) == 0); |
| 543 WriteByte(kSpecializedTagHighBit | static_cast<uint8_t>(tag) | payload); |
| 544 } |
| 545 |
| 546 void WriteBytes(uint8_t* bytes, int length) { |
| 547 out_->WriteBytes(bytes, length); |
| 548 offset_ += length; |
| 549 } |
| 550 |
| 551 template <typename T> |
| 552 void WriteOptional(T* object) { |
| 553 if (object == NULL) { |
| 554 WriteTag(kNothing); |
| 555 } else { |
| 556 WriteTag(kSomething); |
| 557 object->WriteTo(this); |
| 558 } |
| 559 } |
| 560 |
| 561 template <typename T, typename WT> |
| 562 void WriteOptionalStatic(T* object) { |
| 563 if (object == NULL) { |
| 564 WriteTag(kNothing); |
| 565 } else { |
| 566 WriteTag(kSomething); |
| 567 WT::WriteTo(this, object); |
| 568 } |
| 569 } |
| 570 |
| 571 template <typename T> |
| 572 void WriteOptionalStatic(T* object) { |
| 573 return WriteOptionalStatic<T, T>(object); |
| 574 } |
| 575 |
| 576 void DumpOffset(const char* str) { |
| 577 OS::PrintErr("@%" Pd64 " %s\n", offset_, str); |
| 578 } |
| 579 |
| 580 WriterHelper* helper() { return &helper_; } |
| 581 |
| 582 private: |
| 583 ByteWriter* out_; |
| 584 WriterHelper helper_; |
| 585 int64_t offset_; |
| 586 }; |
| 587 |
| 588 |
| 589 template <typename T> |
| 590 template <typename IT> |
| 591 void List<T>::ReadFrom(Reader* reader, TreeNode* parent) { |
| 592 TRACE_READ_OFFSET(); |
| 593 ASSERT(parent != NULL); |
| 594 int length = reader->ReadListLength(); |
| 595 EnsureInitialized(length); |
| 596 |
| 597 for (int i = 0; i < length_; i++) { |
| 598 IT* object = GetOrCreate<IT>(i, parent); |
| 599 object->ReadFrom(reader); |
| 600 } |
| 601 } |
| 602 |
| 603 |
| 604 template <typename T> |
| 605 template <typename IT> |
| 606 void List<T>::ReadFrom(Reader* reader) { |
| 607 TRACE_READ_OFFSET(); |
| 608 int length = reader->ReadListLength(); |
| 609 EnsureInitialized(length); |
| 610 |
| 611 for (int i = 0; i < length_; i++) { |
| 612 GetOrCreate<IT>(i)->ReadFrom(reader); |
| 613 } |
| 614 } |
| 615 |
| 616 |
| 617 template <typename T> |
| 618 template <typename IT> |
| 619 void List<T>::ReadFromStatic(Reader* reader) { |
| 620 TRACE_READ_OFFSET(); |
| 621 int length = reader->ReadListLength(); |
| 622 EnsureInitialized(length); |
| 623 |
| 624 for (int i = 0; i < length_; i++) { |
| 625 ASSERT(array_[i] == NULL); |
| 626 array_[i] = IT::ReadFrom(reader); |
| 627 } |
| 628 } |
| 629 |
| 630 |
| 631 template <typename T> |
| 632 void List<T>::WriteTo(Writer* writer) { |
| 633 TRACE_WRITE_OFFSET(); |
| 634 |
| 635 // NOTE: We only support dense lists. |
| 636 writer->WriteListLength(length_); |
| 637 for (int i = 0; i < length_; i++) { |
| 638 T* object = array_[i]; |
| 639 ASSERT(object != NULL); |
| 640 object->WriteTo(writer); |
| 641 } |
| 642 } |
| 643 |
| 644 |
| 645 template <typename T> |
| 646 template <typename IT> |
| 647 void List<T>::WriteToStatic(Writer* writer) { |
| 648 TRACE_WRITE_OFFSET(); |
| 649 |
| 650 // NOTE: We only support dense lists. |
| 651 writer->WriteListLength(length_); |
| 652 for (int i = 0; i < length_; i++) { |
| 653 T* object = array_[i]; |
| 654 ASSERT(object != NULL); |
| 655 IT::WriteTo(writer, object); |
| 656 } |
| 657 } |
| 658 |
| 659 |
| 660 void TypeParameterList::ReadFrom(Reader* reader) { |
| 661 // It is possible for the bound of the first type parameter to refer to |
| 662 // the second type parameter. This means we need to create [TypeParameter] |
| 663 // objects before reading the bounds. |
| 664 int length = reader->ReadListLength(); |
| 665 EnsureInitialized(length); |
| 666 |
| 667 // Make all [TypeParameter]s available in scope. |
| 668 for (int i = 0; i < length; i++) { |
| 669 TypeParameter* parameter = (*this)[i] = new TypeParameter(); |
| 670 reader->helper()->type_parameters().Push(parameter); |
| 671 } |
| 672 |
| 673 // Read all [TypeParameter]s and their bounds. |
| 674 for (int i = 0; i < length; i++) { |
| 675 (*this)[i]->ReadFrom(reader); |
| 676 } |
| 677 } |
| 678 |
| 679 |
| 680 void TypeParameterList::WriteTo(Writer* writer) { |
| 681 writer->WriteListLength(length()); |
| 682 |
| 683 // Make all [TypeParameter]s available in scope. |
| 684 for (int i = 0; i < length(); i++) { |
| 685 TypeParameter* parameter = (*this)[i]; |
| 686 writer->helper()->type_parameters().Push(parameter); |
| 687 } |
| 688 |
| 689 // Write all [TypeParameter]s and their bounds. |
| 690 for (int i = 0; i < length(); i++) { |
| 691 TypeParameter* parameter = (*this)[i]; |
| 692 parameter->WriteTo(writer); |
| 693 } |
| 694 } |
| 695 |
| 696 |
| 697 template <typename A, typename B> |
| 698 Tuple<A, B>* Tuple<A, B>::ReadFrom(Reader* reader) { |
| 699 TRACE_READ_OFFSET(); |
| 700 A* first = A::ReadFrom(reader); |
| 701 B* second = B::ReadFrom(reader); |
| 702 return new Tuple<A, B>(first, second); |
| 703 } |
| 704 |
| 705 |
| 706 template <typename A, typename B> |
| 707 void Tuple<A, B>::WriteTo(Writer* writer) { |
| 708 TRACE_WRITE_OFFSET(); |
| 709 first_->WriteTo(writer); |
| 710 second_->WriteTo(writer); |
| 711 } |
| 712 |
| 713 |
| 714 template <typename B, typename S> |
| 715 class DowncastReader { |
| 716 public: |
| 717 static S* ReadFrom(Reader* reader) { |
| 718 TRACE_READ_OFFSET(); |
| 719 return S::Cast(B::ReadFrom(reader)); |
| 720 } |
| 721 }; |
| 722 |
| 723 |
| 724 class StringImpl { |
| 725 public: |
| 726 static String* ReadFrom(Reader* reader) { |
| 727 TRACE_READ_OFFSET(); |
| 728 return String::ReadFromImpl(reader); |
| 729 } |
| 730 |
| 731 static void WriteTo(Writer* writer, String* string) { |
| 732 TRACE_WRITE_OFFSET(); |
| 733 string->WriteToImpl(writer); |
| 734 } |
| 735 }; |
| 736 |
| 737 |
| 738 class VariableDeclarationImpl { |
| 739 public: |
| 740 static VariableDeclaration* ReadFrom(Reader* reader) { |
| 741 TRACE_READ_OFFSET(); |
| 742 return VariableDeclaration::ReadFromImpl(reader); |
| 743 } |
| 744 |
| 745 static void WriteTo(Writer* writer, VariableDeclaration* d) { |
| 746 TRACE_WRITE_OFFSET(); |
| 747 d->WriteToImpl(writer); |
| 748 } |
| 749 }; |
| 750 |
| 751 |
| 752 String* String::ReadFrom(Reader* reader) { |
| 753 TRACE_READ_OFFSET(); |
| 754 return Reference::ReadStringFrom(reader); |
| 755 } |
| 756 |
| 757 |
| 758 String* String::ReadFromImpl(Reader* reader) { |
| 759 TRACE_READ_OFFSET(); |
| 760 uint32_t bytes = reader->ReadUInt(); |
| 761 String* string = new String(reader->Consume(bytes), bytes); |
| 762 return string; |
| 763 } |
| 764 |
| 765 |
| 766 void String::WriteTo(Writer* writer) { |
| 767 TRACE_WRITE_OFFSET(); |
| 768 Reference::WriteStringTo(writer, this); |
| 769 } |
| 770 |
| 771 |
| 772 void String::WriteToImpl(Writer* writer) { |
| 773 TRACE_WRITE_OFFSET(); |
| 774 writer->WriteUInt(size_); |
| 775 writer->WriteBytes(buffer_, size_); |
| 776 } |
| 777 |
| 778 |
| 779 void StringTable::ReadFrom(Reader* reader) { |
| 780 strings_.ReadFromStatic<StringImpl>(reader); |
| 781 } |
| 782 |
| 783 |
| 784 void StringTable::WriteTo(Writer* writer) { |
| 785 strings_.WriteToStatic<StringImpl>(writer); |
| 786 |
| 787 // Build up the "String* -> index" table. |
| 788 WriterHelper* helper = writer->helper(); |
| 789 for (int i = 0; i < strings_.length(); i++) { |
| 790 helper->strings().Push(strings_[i]); |
| 791 } |
| 792 } |
| 793 |
| 794 |
| 795 void LineStartingTable::ReadFrom(Reader* reader, intptr_t length) { |
| 796 size_ = length; |
| 797 values_ = new intptr_t*[size_]; |
| 798 for (intptr_t i = 0; i < size_; ++i) { |
| 799 intptr_t line_count = reader->ReadUInt(); |
| 800 intptr_t* line_starts = new intptr_t[line_count + 1]; |
| 801 line_starts[0] = line_count; |
| 802 intptr_t previous_line_start = 0; |
| 803 for (intptr_t j = 0; j < line_count; ++j) { |
| 804 intptr_t lineStart = reader->ReadUInt() + previous_line_start; |
| 805 line_starts[j + 1] = lineStart; |
| 806 previous_line_start = lineStart; |
| 807 } |
| 808 values_[i] = line_starts; |
| 809 } |
| 810 } |
| 811 |
| 812 |
| 813 void LineStartingTable::WriteTo(Writer* writer) { |
| 814 for (intptr_t i = 0; i < size_; ++i) { |
| 815 intptr_t* line_starts = values_[i]; |
| 816 intptr_t line_count = line_starts[0]; |
| 817 writer->WriteUInt(line_count); |
| 818 |
| 819 intptr_t previous_line_start = 0; |
| 820 for (intptr_t j = 0; j < line_count; ++j) { |
| 821 intptr_t line_start = line_starts[j + 1]; |
| 822 writer->WriteUInt(line_start - previous_line_start); |
| 823 previous_line_start = line_start; |
| 824 } |
| 825 } |
| 826 } |
| 827 |
| 828 |
| 829 Library* Library::ReadFrom(Reader* reader) { |
| 830 TRACE_READ_OFFSET(); |
| 831 int flags = reader->ReadFlags(); |
| 832 ASSERT(flags == 0); // external libraries not supported |
| 833 name_ = Reference::ReadStringFrom(reader); |
| 834 import_uri_ = Reference::ReadStringFrom(reader); |
| 835 reader->ReadUInt(); |
| 836 |
| 837 int num_classes = reader->ReadUInt(); |
| 838 classes().EnsureInitialized(num_classes); |
| 839 for (int i = 0; i < num_classes; i++) { |
| 840 Tag tag = reader->ReadTag(); |
| 841 if (tag == kNormalClass) { |
| 842 NormalClass* klass = classes().GetOrCreate<NormalClass>(i, this); |
| 843 klass->ReadFrom(reader); |
| 844 } else { |
| 845 ASSERT(tag == kMixinClass); |
| 846 MixinClass* klass = classes().GetOrCreate<MixinClass>(i, this); |
| 847 klass->ReadFrom(reader); |
| 848 } |
| 849 } |
| 850 |
| 851 fields().ReadFrom<Field>(reader, this); |
| 852 procedures().ReadFrom<Procedure>(reader, this); |
| 853 return this; |
| 854 } |
| 855 |
| 856 |
| 857 void Library::WriteTo(Writer* writer) { |
| 858 TRACE_WRITE_OFFSET(); |
| 859 name_->WriteTo(writer); |
| 860 import_uri_->WriteTo(writer); |
| 861 writer->WriteUInt(0); |
| 862 |
| 863 writer->WriteUInt(classes_.length()); |
| 864 for (int i = 0; i < classes_.length(); i++) { |
| 865 Class* klass = classes_[i]; |
| 866 if (klass->IsNormalClass()) { |
| 867 writer->WriteTag(kNormalClass); |
| 868 NormalClass::Cast(klass)->WriteTo(writer); |
| 869 } else { |
| 870 writer->WriteTag(kMixinClass); |
| 871 MixinClass::Cast(klass)->WriteTo(writer); |
| 872 } |
| 873 } |
| 874 fields().WriteTo(writer); |
| 875 procedures().WriteTo(writer); |
| 876 } |
| 877 |
| 878 |
| 879 Class* Class::ReadFrom(Reader* reader) { |
| 880 TRACE_READ_OFFSET(); |
| 881 |
| 882 is_abstract_ = reader->ReadBool(); |
| 883 name_ = Reference::ReadStringFrom(reader); |
| 884 reader->ReadUInt(); |
| 885 annotations_.ReadFromStatic<Expression>(reader); |
| 886 |
| 887 return this; |
| 888 } |
| 889 |
| 890 |
| 891 void Class::WriteTo(Writer* writer) { |
| 892 TRACE_WRITE_OFFSET(); |
| 893 writer->WriteBool(is_abstract_); |
| 894 name_->WriteTo(writer); |
| 895 writer->WriteUInt(0); |
| 896 annotations_.WriteTo(writer); |
| 897 } |
| 898 |
| 899 |
| 900 NormalClass* NormalClass::ReadFrom(Reader* reader) { |
| 901 TRACE_READ_OFFSET(); |
| 902 Class::ReadFrom(reader); |
| 903 TypeParameterScope<ReaderHelper> scope(reader->helper()); |
| 904 |
| 905 type_parameters_.ReadFrom(reader); |
| 906 DartType* type = reader->ReadOptional<DartType>(); |
| 907 |
| 908 super_class_ = InterfaceType::Cast(type); |
| 909 implemented_classes_.ReadFromStatic<DowncastReader<DartType, InterfaceType> >( |
| 910 reader); |
| 911 fields_.ReadFrom<Field>(reader, this); |
| 912 constructors_.ReadFrom<Constructor>(reader, this); |
| 913 procedures_.ReadFrom<Procedure>(reader, this); |
| 914 |
| 915 return this; |
| 916 } |
| 917 |
| 918 |
| 919 void NormalClass::WriteTo(Writer* writer) { |
| 920 TRACE_WRITE_OFFSET(); |
| 921 Class::WriteTo(writer); |
| 922 TypeParameterScope<WriterHelper> scope(writer->helper()); |
| 923 |
| 924 type_parameters().WriteTo(writer); |
| 925 writer->WriteOptional<DartType>(super_class_); |
| 926 implemented_classes().WriteTo(writer); |
| 927 fields_.WriteTo(writer); |
| 928 constructors_.WriteTo(writer); |
| 929 procedures_.WriteTo(writer); |
| 930 } |
| 931 |
| 932 |
| 933 MixinClass* MixinClass::ReadFrom(Reader* reader) { |
| 934 TRACE_READ_OFFSET(); |
| 935 TypeParameterScope<ReaderHelper> scope(reader->helper()); |
| 936 |
| 937 Class::ReadFrom(reader); |
| 938 type_parameters_.ReadFrom(reader); |
| 939 first_ = InterfaceType::Cast(DartType::ReadFrom(reader)); |
| 940 second_ = InterfaceType::Cast(DartType::ReadFrom(reader)); |
| 941 implemented_classes_.ReadFromStatic<DowncastReader<DartType, InterfaceType> >( |
| 942 reader); |
| 943 constructors_.ReadFrom<Constructor>(reader, this); |
| 944 return this; |
| 945 } |
| 946 |
| 947 |
| 948 void MixinClass::WriteTo(Writer* writer) { |
| 949 TRACE_WRITE_OFFSET(); |
| 950 TypeParameterScope<WriterHelper> scope(writer->helper()); |
| 951 |
| 952 Class::WriteTo(writer); |
| 953 type_parameters_.WriteTo(writer); |
| 954 first_->WriteTo(writer); |
| 955 second_->WriteTo(writer); |
| 956 implemented_classes_.WriteTo(writer); |
| 957 constructors_.WriteTo(writer); |
| 958 } |
| 959 |
| 960 |
| 961 Member* Reference::ReadMemberFrom(Reader* reader, bool allow_null) { |
| 962 TRACE_READ_OFFSET(); |
| 963 |
| 964 Program* program = reader->helper()->program(); |
| 965 Tag tag = reader->ReadTag(); |
| 966 switch (tag) { |
| 967 case kLibraryFieldReference: { |
| 968 int library_idx = reader->ReadUInt(); |
| 969 int field_idx = reader->ReadUInt(); |
| 970 Library* library = program->libraries().GetOrCreate<Library>(library_idx); |
| 971 return library->fields().GetOrCreate<Field>(field_idx, library); |
| 972 } |
| 973 case kLibraryProcedureReference: { |
| 974 int library_idx = reader->ReadUInt(); |
| 975 int procedure_idx = reader->ReadUInt(); |
| 976 Library* library = program->libraries().GetOrCreate<Library>(library_idx); |
| 977 return library->procedures().GetOrCreate<Procedure>(procedure_idx, |
| 978 library); |
| 979 } |
| 980 case kClassFieldReference: |
| 981 case kClassConstructorReference: |
| 982 case kClassProcedureReference: { |
| 983 Class* klass = Reference::ReadClassFrom(reader); |
| 984 if (tag == kClassFieldReference) { |
| 985 int field_idx = reader->ReadUInt(); |
| 986 return klass->fields().GetOrCreate<Field>(field_idx, klass); |
| 987 } else if (tag == kClassConstructorReference) { |
| 988 int constructor_idx = reader->ReadUInt(); |
| 989 return klass->constructors().GetOrCreate<Constructor>(constructor_idx, |
| 990 klass); |
| 991 } else { |
| 992 ASSERT(tag == kClassProcedureReference); |
| 993 int procedure_idx = reader->ReadUInt(); |
| 994 return klass->procedures().GetOrCreate<Procedure>(procedure_idx, klass); |
| 995 } |
| 996 } |
| 997 case kNullReference: |
| 998 if (allow_null) { |
| 999 return NULL; |
| 1000 } else { |
| 1001 FATAL("Expected a valid member reference, but got `null`"); |
| 1002 } |
| 1003 default: |
| 1004 UNREACHABLE(); |
| 1005 break; |
| 1006 } |
| 1007 |
| 1008 UNREACHABLE(); |
| 1009 return NULL; |
| 1010 } |
| 1011 |
| 1012 |
| 1013 void Reference::WriteMemberTo(Writer* writer, Member* member, bool allow_null) { |
| 1014 TRACE_WRITE_OFFSET(); |
| 1015 if (member == NULL) { |
| 1016 if (allow_null) { |
| 1017 writer->WriteTag(kNullReference); |
| 1018 return; |
| 1019 } else { |
| 1020 FATAL("Expected a valid member reference but got `null`"); |
| 1021 } |
| 1022 } |
| 1023 TreeNode* node = member->parent(); |
| 1024 |
| 1025 WriterHelper* helper = writer->helper(); |
| 1026 |
| 1027 if (node->IsLibrary()) { |
| 1028 Library* library = Library::Cast(node); |
| 1029 if (member->IsField()) { |
| 1030 Field* field = Field::Cast(member); |
| 1031 writer->WriteTag(kLibraryFieldReference); |
| 1032 writer->WriteUInt(helper->libraries().Lookup(library)); |
| 1033 writer->WriteUInt(helper->fields().Lookup(field)); |
| 1034 } else { |
| 1035 Procedure* procedure = Procedure::Cast(member); |
| 1036 writer->WriteTag(kLibraryProcedureReference); |
| 1037 writer->WriteUInt(helper->libraries().Lookup(library)); |
| 1038 writer->WriteUInt(helper->procedures().Lookup(procedure)); |
| 1039 } |
| 1040 } else { |
| 1041 Class* klass = Class::Cast(node); |
| 1042 |
| 1043 if (member->IsField()) { |
| 1044 Field* field = Field::Cast(member); |
| 1045 writer->WriteTag(kClassFieldReference); |
| 1046 Reference::WriteClassTo(writer, klass); |
| 1047 writer->WriteUInt(helper->fields().Lookup(field)); |
| 1048 } else if (member->IsConstructor()) { |
| 1049 Constructor* constructor = Constructor::Cast(member); |
| 1050 writer->WriteTag(kClassConstructorReference); |
| 1051 Reference::WriteClassTo(writer, klass); |
| 1052 writer->WriteUInt(helper->constructors().Lookup(constructor)); |
| 1053 } else { |
| 1054 Procedure* procedure = Procedure::Cast(member); |
| 1055 writer->WriteTag(kClassProcedureReference); |
| 1056 Reference::WriteClassTo(writer, klass); |
| 1057 writer->WriteUInt(helper->procedures().Lookup(procedure)); |
| 1058 } |
| 1059 } |
| 1060 } |
| 1061 |
| 1062 |
| 1063 Class* Reference::ReadClassFrom(Reader* reader, bool allow_null) { |
| 1064 TRACE_READ_OFFSET(); |
| 1065 Program* program = reader->helper()->program(); |
| 1066 |
| 1067 Tag klass_member_tag = reader->ReadTag(); |
| 1068 if (klass_member_tag == kNullReference) { |
| 1069 if (allow_null) { |
| 1070 return NULL; |
| 1071 } else { |
| 1072 FATAL("Expected a valid class reference but got `null`."); |
| 1073 } |
| 1074 } |
| 1075 int library_idx = reader->ReadUInt(); |
| 1076 int class_idx = reader->ReadUInt(); |
| 1077 |
| 1078 Library* library = program->libraries().GetOrCreate<Library>(library_idx); |
| 1079 Class* klass; |
| 1080 if (klass_member_tag == kNormalClassReference) { |
| 1081 klass = library->classes().GetOrCreate<NormalClass>(class_idx, library); |
| 1082 } else { |
| 1083 ASSERT(klass_member_tag == kMixinClassReference); |
| 1084 klass = library->classes().GetOrCreate<MixinClass>(class_idx, library); |
| 1085 } |
| 1086 return klass; |
| 1087 } |
| 1088 |
| 1089 |
| 1090 void Reference::WriteClassTo(Writer* writer, Class* klass, bool allow_null) { |
| 1091 TRACE_WRITE_OFFSET(); |
| 1092 if (klass == NULL) { |
| 1093 if (allow_null) { |
| 1094 writer->WriteTag(kNullReference); |
| 1095 return; |
| 1096 } else { |
| 1097 FATAL("Expected a valid class reference but got `null`."); |
| 1098 } |
| 1099 } |
| 1100 if (klass->IsNormalClass()) { |
| 1101 writer->WriteTag(kNormalClassReference); |
| 1102 } else { |
| 1103 ASSERT(klass->IsMixinClass()); |
| 1104 writer->WriteTag(kMixinClassReference); |
| 1105 } |
| 1106 |
| 1107 writer->WriteUInt(writer->helper()->libraries().Lookup(klass->parent())); |
| 1108 writer->WriteUInt(writer->helper()->classes().Lookup(klass)); |
| 1109 } |
| 1110 |
| 1111 |
| 1112 String* Reference::ReadStringFrom(Reader* reader) { |
| 1113 int index = reader->ReadUInt(); |
| 1114 return reader->helper()->program()->string_table().strings()[index]; |
| 1115 } |
| 1116 |
| 1117 |
| 1118 void Reference::WriteStringTo(Writer* writer, String* string) { |
| 1119 int index = writer->helper()->strings().Lookup(string); |
| 1120 writer->WriteUInt(index); |
| 1121 } |
| 1122 |
| 1123 |
| 1124 Field* Field::ReadFrom(Reader* reader) { |
| 1125 TRACE_READ_OFFSET(); |
| 1126 Tag tag = reader->ReadTag(); |
| 1127 ASSERT(tag == kField); |
| 1128 |
| 1129 reader->ReadUInt(); |
| 1130 flags_ = reader->ReadFlags(); |
| 1131 name_ = Name::ReadFrom(reader); |
| 1132 reader->ReadUInt(); |
| 1133 annotations_.ReadFromStatic<Expression>(reader); |
| 1134 type_ = DartType::ReadFrom(reader); |
| 1135 inferred_value_ = reader->ReadOptional<InferredValue>(); |
| 1136 initializer_ = reader->ReadOptional<Expression>(); |
| 1137 return this; |
| 1138 } |
| 1139 |
| 1140 |
| 1141 void Field::WriteTo(Writer* writer) { |
| 1142 TRACE_WRITE_OFFSET(); |
| 1143 writer->WriteTag(kField); |
| 1144 writer->WriteUInt(0); |
| 1145 writer->WriteFlags(flags_); |
| 1146 name_->WriteTo(writer); |
| 1147 writer->WriteUInt(0); |
| 1148 annotations_.WriteTo(writer); |
| 1149 type_->WriteTo(writer); |
| 1150 writer->WriteOptional<InferredValue>(inferred_value_); |
| 1151 writer->WriteOptional<Expression>(initializer_); |
| 1152 } |
| 1153 |
| 1154 |
| 1155 Constructor* Constructor::ReadFrom(Reader* reader) { |
| 1156 TRACE_READ_OFFSET(); |
| 1157 Tag tag = reader->ReadTag(); |
| 1158 ASSERT(tag == kConstructor); |
| 1159 |
| 1160 VariableScope<ReaderHelper> parameters(reader->helper()); |
| 1161 flags_ = reader->ReadFlags(); |
| 1162 name_ = Name::ReadFrom(reader); |
| 1163 annotations_.ReadFromStatic<Expression>(reader); |
| 1164 function_ = FunctionNode::ReadFrom(reader); |
| 1165 initializers_.ReadFromStatic<Initializer>(reader); |
| 1166 return this; |
| 1167 } |
| 1168 |
| 1169 |
| 1170 void Constructor::WriteTo(Writer* writer) { |
| 1171 TRACE_WRITE_OFFSET(); |
| 1172 writer->WriteTag(kConstructor); |
| 1173 |
| 1174 VariableScope<WriterHelper> parameters(writer->helper()); |
| 1175 writer->WriteFlags(flags_); |
| 1176 name_->WriteTo(writer); |
| 1177 annotations_.WriteTo(writer); |
| 1178 function_->WriteTo(writer); |
| 1179 initializers_.WriteTo(writer); |
| 1180 } |
| 1181 |
| 1182 |
| 1183 Procedure* Procedure::ReadFrom(Reader* reader) { |
| 1184 TRACE_READ_OFFSET(); |
| 1185 Tag tag = reader->ReadTag(); |
| 1186 ASSERT(tag == kProcedure); |
| 1187 |
| 1188 VariableScope<ReaderHelper> parameters(reader->helper()); |
| 1189 kind_ = static_cast<ProcedureKind>(reader->ReadByte()); |
| 1190 flags_ = reader->ReadFlags(); |
| 1191 name_ = Name::ReadFrom(reader); |
| 1192 reader->ReadUInt(); |
| 1193 annotations_.ReadFromStatic<Expression>(reader); |
| 1194 function_ = reader->ReadOptional<FunctionNode>(); |
| 1195 return this; |
| 1196 } |
| 1197 |
| 1198 |
| 1199 void Procedure::WriteTo(Writer* writer) { |
| 1200 TRACE_WRITE_OFFSET(); |
| 1201 writer->WriteTag(kProcedure); |
| 1202 |
| 1203 VariableScope<WriterHelper> parameters(writer->helper()); |
| 1204 writer->WriteByte(kind_); |
| 1205 writer->WriteFlags(flags_); |
| 1206 name_->WriteTo(writer); |
| 1207 writer->WriteUInt(0); |
| 1208 annotations_.WriteTo(writer); |
| 1209 writer->WriteOptional<FunctionNode>(function_); |
| 1210 } |
| 1211 |
| 1212 |
| 1213 Initializer* Initializer::ReadFrom(Reader* reader) { |
| 1214 TRACE_READ_OFFSET(); |
| 1215 Tag tag = reader->ReadTag(); |
| 1216 switch (tag) { |
| 1217 case kInvalidInitializer: |
| 1218 return InvalidInitializer::ReadFromImpl(reader); |
| 1219 case kFieldInitializer: |
| 1220 return FieldInitializer::ReadFromImpl(reader); |
| 1221 case kSuperInitializer: |
| 1222 return SuperInitializer::ReadFromImpl(reader); |
| 1223 case kRedirectingInitializer: |
| 1224 return RedirectingInitializer::ReadFromImpl(reader); |
| 1225 case kLocalInitializer: |
| 1226 return LocalInitializer::ReadFromImpl(reader); |
| 1227 default: |
| 1228 UNREACHABLE(); |
| 1229 } |
| 1230 return NULL; |
| 1231 } |
| 1232 |
| 1233 |
| 1234 InvalidInitializer* InvalidInitializer::ReadFromImpl(Reader* reader) { |
| 1235 TRACE_READ_OFFSET(); |
| 1236 return new InvalidInitializer(); |
| 1237 } |
| 1238 |
| 1239 |
| 1240 void InvalidInitializer::WriteTo(Writer* writer) { |
| 1241 TRACE_WRITE_OFFSET(); |
| 1242 writer->WriteTag(kInvalidInitializer); |
| 1243 } |
| 1244 |
| 1245 |
| 1246 FieldInitializer* FieldInitializer::ReadFromImpl(Reader* reader) { |
| 1247 TRACE_READ_OFFSET(); |
| 1248 FieldInitializer* initializer = new FieldInitializer(); |
| 1249 initializer->field_ = Field::Cast(Reference::ReadMemberFrom(reader)); |
| 1250 initializer->value_ = Expression::ReadFrom(reader); |
| 1251 return initializer; |
| 1252 } |
| 1253 |
| 1254 |
| 1255 void FieldInitializer::WriteTo(Writer* writer) { |
| 1256 TRACE_WRITE_OFFSET(); |
| 1257 writer->WriteTag(kFieldInitializer); |
| 1258 Reference::WriteMemberTo(writer, field_); |
| 1259 value_->WriteTo(writer); |
| 1260 } |
| 1261 |
| 1262 |
| 1263 SuperInitializer* SuperInitializer::ReadFromImpl(Reader* reader) { |
| 1264 TRACE_READ_OFFSET(); |
| 1265 SuperInitializer* init = new SuperInitializer(); |
| 1266 init->target_ = Constructor::Cast(Reference::ReadMemberFrom(reader)); |
| 1267 init->arguments_ = Arguments::ReadFrom(reader); |
| 1268 return init; |
| 1269 } |
| 1270 |
| 1271 |
| 1272 void SuperInitializer::WriteTo(Writer* writer) { |
| 1273 TRACE_WRITE_OFFSET(); |
| 1274 writer->WriteTag(kSuperInitializer); |
| 1275 Reference::WriteMemberTo(writer, target_); |
| 1276 arguments_->WriteTo(writer); |
| 1277 } |
| 1278 |
| 1279 |
| 1280 RedirectingInitializer* RedirectingInitializer::ReadFromImpl(Reader* reader) { |
| 1281 TRACE_READ_OFFSET(); |
| 1282 RedirectingInitializer* init = new RedirectingInitializer(); |
| 1283 init->target_ = Constructor::Cast(Reference::ReadMemberFrom(reader)); |
| 1284 init->arguments_ = Arguments::ReadFrom(reader); |
| 1285 return init; |
| 1286 } |
| 1287 |
| 1288 |
| 1289 void RedirectingInitializer::WriteTo(Writer* writer) { |
| 1290 TRACE_WRITE_OFFSET(); |
| 1291 writer->WriteTag(kRedirectingInitializer); |
| 1292 Reference::WriteMemberTo(writer, target_); |
| 1293 arguments_->WriteTo(writer); |
| 1294 } |
| 1295 |
| 1296 |
| 1297 LocalInitializer* LocalInitializer::ReadFromImpl(Reader* reader) { |
| 1298 TRACE_READ_OFFSET(); |
| 1299 LocalInitializer* init = new LocalInitializer(); |
| 1300 init->variable_ = VariableDeclaration::ReadFromImpl(reader); |
| 1301 return init; |
| 1302 } |
| 1303 |
| 1304 |
| 1305 void LocalInitializer::WriteTo(Writer* writer) { |
| 1306 TRACE_WRITE_OFFSET(); |
| 1307 writer->WriteTag(kLocalInitializer); |
| 1308 variable_->WriteToImpl(writer); |
| 1309 } |
| 1310 |
| 1311 |
| 1312 Expression* Expression::ReadFrom(Reader* reader) { |
| 1313 TRACE_READ_OFFSET(); |
| 1314 uint8_t payload = 0; |
| 1315 Tag tag = reader->ReadTag(&payload); |
| 1316 switch (tag) { |
| 1317 case kInvalidExpression: |
| 1318 return InvalidExpression::ReadFrom(reader); |
| 1319 case kVariableGet: |
| 1320 return VariableGet::ReadFrom(reader); |
| 1321 case kSpecializedVariableGet: |
| 1322 return VariableGet::ReadFrom(reader, payload); |
| 1323 case kVariableSet: |
| 1324 return VariableSet::ReadFrom(reader); |
| 1325 case kSpecializedVariableSet: |
| 1326 return VariableSet::ReadFrom(reader, payload); |
| 1327 case kPropertyGet: |
| 1328 return PropertyGet::ReadFrom(reader); |
| 1329 case kPropertySet: |
| 1330 return PropertySet::ReadFrom(reader); |
| 1331 case kDirectPropertyGet: |
| 1332 return DirectPropertyGet::ReadFrom(reader); |
| 1333 case kDirectPropertySet: |
| 1334 return DirectPropertySet::ReadFrom(reader); |
| 1335 case kStaticGet: |
| 1336 return StaticGet::ReadFrom(reader); |
| 1337 case kStaticSet: |
| 1338 return StaticSet::ReadFrom(reader); |
| 1339 case kMethodInvocation: |
| 1340 return MethodInvocation::ReadFrom(reader); |
| 1341 case kDirectMethodInvocation: |
| 1342 return DirectMethodInvocation::ReadFrom(reader); |
| 1343 case kStaticInvocation: |
| 1344 return StaticInvocation::ReadFrom(reader, false); |
| 1345 case kConstStaticInvocation: |
| 1346 return StaticInvocation::ReadFrom(reader, true); |
| 1347 case kConstructorInvocation: |
| 1348 return ConstructorInvocation::ReadFrom(reader, false); |
| 1349 case kConstConstructorInvocation: |
| 1350 return ConstructorInvocation::ReadFrom(reader, true); |
| 1351 case kNot: |
| 1352 return Not::ReadFrom(reader); |
| 1353 case kLogicalExpression: |
| 1354 return LogicalExpression::ReadFrom(reader); |
| 1355 case kConditionalExpression: |
| 1356 return ConditionalExpression::ReadFrom(reader); |
| 1357 case kStringConcatenation: |
| 1358 return StringConcatenation::ReadFrom(reader); |
| 1359 case kIsExpression: |
| 1360 return IsExpression::ReadFrom(reader); |
| 1361 case kAsExpression: |
| 1362 return AsExpression::ReadFrom(reader); |
| 1363 case kSymbolLiteral: |
| 1364 return SymbolLiteral::ReadFrom(reader); |
| 1365 case kTypeLiteral: |
| 1366 return TypeLiteral::ReadFrom(reader); |
| 1367 case kThisExpression: |
| 1368 return ThisExpression::ReadFrom(reader); |
| 1369 case kRethrow: |
| 1370 return Rethrow::ReadFrom(reader); |
| 1371 case kThrow: |
| 1372 return Throw::ReadFrom(reader); |
| 1373 case kListLiteral: |
| 1374 return ListLiteral::ReadFrom(reader, false); |
| 1375 case kConstListLiteral: |
| 1376 return ListLiteral::ReadFrom(reader, true); |
| 1377 case kMapLiteral: |
| 1378 return MapLiteral::ReadFrom(reader, false); |
| 1379 case kConstMapLiteral: |
| 1380 return MapLiteral::ReadFrom(reader, true); |
| 1381 case kAwaitExpression: |
| 1382 return AwaitExpression::ReadFrom(reader); |
| 1383 case kFunctionExpression: |
| 1384 return FunctionExpression::ReadFrom(reader); |
| 1385 case kLet: |
| 1386 return Let::ReadFrom(reader); |
| 1387 case kBlockExpression: |
| 1388 return BlockExpression::ReadFrom(reader); |
| 1389 case kBigIntLiteral: |
| 1390 return BigintLiteral::ReadFrom(reader); |
| 1391 case kStringLiteral: |
| 1392 return StringLiteral::ReadFrom(reader); |
| 1393 case kSpecialIntLiteral: |
| 1394 return IntLiteral::ReadFrom(reader, payload); |
| 1395 case kNegativeIntLiteral: |
| 1396 return IntLiteral::ReadFrom(reader, true); |
| 1397 case kPositiveIntLiteral: |
| 1398 return IntLiteral::ReadFrom(reader, false); |
| 1399 case kDoubleLiteral: |
| 1400 return DoubleLiteral::ReadFrom(reader); |
| 1401 case kTrueLiteral: |
| 1402 return BoolLiteral::ReadFrom(reader, true); |
| 1403 case kFalseLiteral: |
| 1404 return BoolLiteral::ReadFrom(reader, false); |
| 1405 case kNullLiteral: |
| 1406 return NullLiteral::ReadFrom(reader); |
| 1407 default: |
| 1408 UNREACHABLE(); |
| 1409 } |
| 1410 return NULL; |
| 1411 } |
| 1412 |
| 1413 |
| 1414 InvalidExpression* InvalidExpression::ReadFrom(Reader* reader) { |
| 1415 TRACE_READ_OFFSET(); |
| 1416 return new InvalidExpression(); |
| 1417 } |
| 1418 |
| 1419 |
| 1420 void InvalidExpression::WriteTo(Writer* writer) { |
| 1421 TRACE_WRITE_OFFSET(); |
| 1422 writer->WriteTag(kInvalidExpression); |
| 1423 } |
| 1424 |
| 1425 |
| 1426 VariableGet* VariableGet::ReadFrom(Reader* reader) { |
| 1427 TRACE_READ_OFFSET(); |
| 1428 VariableGet* get = new VariableGet(); |
| 1429 get->variable_ = reader->helper()->variables().Lookup(reader->ReadUInt()); |
| 1430 reader->ReadOptional<DartType>(); // Unused promoted type. |
| 1431 return get; |
| 1432 } |
| 1433 |
| 1434 |
| 1435 VariableGet* VariableGet::ReadFrom(Reader* reader, uint8_t payload) { |
| 1436 TRACE_READ_OFFSET(); |
| 1437 VariableGet* get = new VariableGet(); |
| 1438 get->variable_ = reader->helper()->variables().Lookup(payload); |
| 1439 return get; |
| 1440 } |
| 1441 |
| 1442 |
| 1443 void VariableGet::WriteTo(Writer* writer) { |
| 1444 TRACE_WRITE_OFFSET(); |
| 1445 int index = writer->helper()->variables().Lookup(variable_); |
| 1446 if ((index & kSpecializedPayloadMask) == index) { |
| 1447 writer->WriteTag(kSpecializedVariableGet, static_cast<uint8_t>(index)); |
| 1448 } else { |
| 1449 writer->WriteTag(kVariableGet); |
| 1450 writer->WriteUInt(index); |
| 1451 writer->WriteOptional<DartType>(NULL); |
| 1452 } |
| 1453 } |
| 1454 |
| 1455 |
| 1456 VariableSet* VariableSet::ReadFrom(Reader* reader) { |
| 1457 TRACE_READ_OFFSET(); |
| 1458 VariableSet* set = new VariableSet(); |
| 1459 set->variable_ = reader->helper()->variables().Lookup(reader->ReadUInt()); |
| 1460 set->expression_ = Expression::ReadFrom(reader); |
| 1461 return set; |
| 1462 } |
| 1463 |
| 1464 |
| 1465 VariableSet* VariableSet::ReadFrom(Reader* reader, uint8_t payload) { |
| 1466 TRACE_READ_OFFSET(); |
| 1467 VariableSet* set = new VariableSet(); |
| 1468 set->variable_ = reader->helper()->variables().Lookup(payload); |
| 1469 set->expression_ = Expression::ReadFrom(reader); |
| 1470 return set; |
| 1471 } |
| 1472 |
| 1473 |
| 1474 void VariableSet::WriteTo(Writer* writer) { |
| 1475 TRACE_WRITE_OFFSET(); |
| 1476 int index = writer->helper()->variables().Lookup(variable_); |
| 1477 if ((index & kSpecializedPayloadMask) == index) { |
| 1478 writer->WriteTag(kSpecializedVariableSet, static_cast<uint8_t>(index)); |
| 1479 } else { |
| 1480 writer->WriteTag(kVariableSet); |
| 1481 writer->WriteUInt(index); |
| 1482 } |
| 1483 expression_->WriteTo(writer); |
| 1484 } |
| 1485 |
| 1486 |
| 1487 PropertyGet* PropertyGet::ReadFrom(Reader* reader) { |
| 1488 TRACE_READ_OFFSET(); |
| 1489 PropertyGet* get = new PropertyGet(); |
| 1490 reader->ReadUInt(); |
| 1491 get->receiver_ = Expression::ReadFrom(reader); |
| 1492 get->name_ = Name::ReadFrom(reader); |
| 1493 get->interfaceTarget_ = Reference::ReadMemberFrom(reader, true); |
| 1494 return get; |
| 1495 } |
| 1496 |
| 1497 |
| 1498 void PropertyGet::WriteTo(Writer* writer) { |
| 1499 TRACE_WRITE_OFFSET(); |
| 1500 writer->WriteTag(kPropertyGet); |
| 1501 writer->WriteUInt(0); |
| 1502 receiver_->WriteTo(writer); |
| 1503 name_->WriteTo(writer); |
| 1504 Reference::WriteMemberTo(writer, interfaceTarget_, true); |
| 1505 } |
| 1506 |
| 1507 |
| 1508 PropertySet* PropertySet::ReadFrom(Reader* reader) { |
| 1509 TRACE_READ_OFFSET(); |
| 1510 PropertySet* set = new PropertySet(); |
| 1511 reader->ReadUInt(); |
| 1512 set->receiver_ = Expression::ReadFrom(reader); |
| 1513 set->name_ = Name::ReadFrom(reader); |
| 1514 set->value_ = Expression::ReadFrom(reader); |
| 1515 set->interfaceTarget_ = Reference::ReadMemberFrom(reader, true); |
| 1516 return set; |
| 1517 } |
| 1518 |
| 1519 |
| 1520 void PropertySet::WriteTo(Writer* writer) { |
| 1521 TRACE_WRITE_OFFSET(); |
| 1522 writer->WriteTag(kPropertySet); |
| 1523 writer->WriteUInt(0); |
| 1524 receiver_->WriteTo(writer); |
| 1525 name_->WriteTo(writer); |
| 1526 value_->WriteTo(writer); |
| 1527 Reference::WriteMemberTo(writer, interfaceTarget_, true); |
| 1528 } |
| 1529 |
| 1530 |
| 1531 DirectPropertyGet* DirectPropertyGet::ReadFrom(Reader* reader) { |
| 1532 TRACE_READ_OFFSET(); |
| 1533 DirectPropertyGet* get = new DirectPropertyGet(); |
| 1534 get->receiver_ = Expression::ReadFrom(reader); |
| 1535 get->target_ = Reference::ReadMemberFrom(reader); |
| 1536 return get; |
| 1537 } |
| 1538 |
| 1539 |
| 1540 void DirectPropertyGet::WriteTo(Writer* writer) { |
| 1541 TRACE_WRITE_OFFSET(); |
| 1542 writer->WriteTag(kDirectPropertyGet); |
| 1543 receiver_->WriteTo(writer); |
| 1544 Reference::WriteMemberTo(writer, target_); |
| 1545 } |
| 1546 |
| 1547 |
| 1548 DirectPropertySet* DirectPropertySet::ReadFrom(Reader* reader) { |
| 1549 TRACE_READ_OFFSET(); |
| 1550 DirectPropertySet* set = new DirectPropertySet(); |
| 1551 set->receiver_ = Expression::ReadFrom(reader); |
| 1552 set->target_ = Reference::ReadMemberFrom(reader); |
| 1553 set->value_ = Expression::ReadFrom(reader); |
| 1554 return set; |
| 1555 } |
| 1556 |
| 1557 |
| 1558 void DirectPropertySet::WriteTo(Writer* writer) { |
| 1559 TRACE_WRITE_OFFSET(); |
| 1560 writer->WriteTag(kDirectPropertySet); |
| 1561 receiver_->WriteTo(writer); |
| 1562 Reference::WriteMemberTo(writer, target_); |
| 1563 value_->WriteTo(writer); |
| 1564 } |
| 1565 |
| 1566 |
| 1567 StaticGet* StaticGet::ReadFrom(Reader* reader) { |
| 1568 TRACE_READ_OFFSET(); |
| 1569 StaticGet* get = new StaticGet(); |
| 1570 reader->ReadUInt(); |
| 1571 get->target_ = Reference::ReadMemberFrom(reader); |
| 1572 return get; |
| 1573 } |
| 1574 |
| 1575 |
| 1576 void StaticGet::WriteTo(Writer* writer) { |
| 1577 TRACE_WRITE_OFFSET(); |
| 1578 writer->WriteTag(kStaticGet); |
| 1579 writer->WriteUInt(0); |
| 1580 Reference::WriteMemberTo(writer, target_); |
| 1581 } |
| 1582 |
| 1583 |
| 1584 StaticSet* StaticSet::ReadFrom(Reader* reader) { |
| 1585 TRACE_READ_OFFSET(); |
| 1586 StaticSet* set = new StaticSet(); |
| 1587 set->target_ = Reference::ReadMemberFrom(reader); |
| 1588 set->expression_ = Expression::ReadFrom(reader); |
| 1589 return set; |
| 1590 } |
| 1591 |
| 1592 |
| 1593 void StaticSet::WriteTo(Writer* writer) { |
| 1594 TRACE_WRITE_OFFSET(); |
| 1595 writer->WriteTag(kStaticSet); |
| 1596 Reference::WriteMemberTo(writer, target_); |
| 1597 expression_->WriteTo(writer); |
| 1598 } |
| 1599 |
| 1600 |
| 1601 Arguments* Arguments::ReadFrom(Reader* reader) { |
| 1602 TRACE_READ_OFFSET(); |
| 1603 Arguments* arguments = new Arguments(); |
| 1604 arguments->types().ReadFromStatic<DartType>(reader); |
| 1605 arguments->positional().ReadFromStatic<Expression>(reader); |
| 1606 arguments->named().ReadFromStatic<NamedExpression>(reader); |
| 1607 return arguments; |
| 1608 } |
| 1609 |
| 1610 |
| 1611 void Arguments::WriteTo(Writer* writer) { |
| 1612 TRACE_WRITE_OFFSET(); |
| 1613 types().WriteTo(writer); |
| 1614 positional().WriteTo(writer); |
| 1615 named().WriteTo(writer); |
| 1616 } |
| 1617 |
| 1618 |
| 1619 NamedExpression* NamedExpression::ReadFrom(Reader* reader) { |
| 1620 TRACE_READ_OFFSET(); |
| 1621 String* name = Reference::ReadStringFrom(reader); |
| 1622 Expression* expression = Expression::ReadFrom(reader); |
| 1623 return new NamedExpression(name, expression); |
| 1624 } |
| 1625 |
| 1626 |
| 1627 void NamedExpression::WriteTo(Writer* writer) { |
| 1628 TRACE_WRITE_OFFSET(); |
| 1629 name_->WriteTo(writer); |
| 1630 expression_->WriteTo(writer); |
| 1631 } |
| 1632 |
| 1633 |
| 1634 MethodInvocation* MethodInvocation::ReadFrom(Reader* reader) { |
| 1635 TRACE_READ_OFFSET(); |
| 1636 MethodInvocation* invocation = new MethodInvocation(); |
| 1637 reader->ReadUInt(); |
| 1638 invocation->receiver_ = Expression::ReadFrom(reader); |
| 1639 invocation->name_ = Name::ReadFrom(reader); |
| 1640 invocation->arguments_ = Arguments::ReadFrom(reader); |
| 1641 invocation->interfaceTarget_ = Reference::ReadMemberFrom(reader, true); |
| 1642 return invocation; |
| 1643 } |
| 1644 |
| 1645 |
| 1646 void MethodInvocation::WriteTo(Writer* writer) { |
| 1647 TRACE_WRITE_OFFSET(); |
| 1648 writer->WriteTag(kMethodInvocation); |
| 1649 writer->WriteUInt(0); |
| 1650 receiver_->WriteTo(writer); |
| 1651 name_->WriteTo(writer); |
| 1652 arguments_->WriteTo(writer); |
| 1653 Reference::WriteMemberTo(writer, interfaceTarget_, true); |
| 1654 } |
| 1655 |
| 1656 |
| 1657 DirectMethodInvocation* DirectMethodInvocation::ReadFrom(Reader* reader) { |
| 1658 TRACE_READ_OFFSET(); |
| 1659 DirectMethodInvocation* invocation = new DirectMethodInvocation(); |
| 1660 invocation->receiver_ = Expression::ReadFrom(reader); |
| 1661 invocation->target_ = Procedure::Cast(Reference::ReadMemberFrom(reader)); |
| 1662 invocation->arguments_ = Arguments::ReadFrom(reader); |
| 1663 return invocation; |
| 1664 } |
| 1665 |
| 1666 |
| 1667 void DirectMethodInvocation::WriteTo(Writer* writer) { |
| 1668 TRACE_WRITE_OFFSET(); |
| 1669 writer->WriteTag(kDirectMethodInvocation); |
| 1670 receiver_->WriteTo(writer); |
| 1671 Reference::WriteMemberTo(writer, target_); |
| 1672 arguments_->WriteTo(writer); |
| 1673 } |
| 1674 |
| 1675 |
| 1676 StaticInvocation* StaticInvocation::ReadFrom(Reader* reader, bool is_const) { |
| 1677 TRACE_READ_OFFSET(); |
| 1678 |
| 1679 reader->ReadUInt(); |
| 1680 Member* member = Reference::ReadMemberFrom(reader); |
| 1681 Arguments* args = Arguments::ReadFrom(reader); |
| 1682 |
| 1683 return new StaticInvocation(Procedure::Cast(member), args, is_const); |
| 1684 } |
| 1685 |
| 1686 |
| 1687 void StaticInvocation::WriteTo(Writer* writer) { |
| 1688 TRACE_WRITE_OFFSET(); |
| 1689 writer->WriteTag(is_const_ ? kConstStaticInvocation : kStaticInvocation); |
| 1690 writer->WriteUInt(0); |
| 1691 Reference::WriteMemberTo(writer, procedure_); |
| 1692 arguments_->WriteTo(writer); |
| 1693 } |
| 1694 |
| 1695 |
| 1696 ConstructorInvocation* ConstructorInvocation::ReadFrom(Reader* reader, |
| 1697 bool is_const) { |
| 1698 TRACE_READ_OFFSET(); |
| 1699 ConstructorInvocation* invocation = new ConstructorInvocation(); |
| 1700 invocation->is_const_ = is_const; |
| 1701 reader->ReadUInt(); |
| 1702 invocation->target_ = Constructor::Cast(Reference::ReadMemberFrom(reader)); |
| 1703 invocation->arguments_ = Arguments::ReadFrom(reader); |
| 1704 return invocation; |
| 1705 } |
| 1706 |
| 1707 |
| 1708 void ConstructorInvocation::WriteTo(Writer* writer) { |
| 1709 TRACE_WRITE_OFFSET(); |
| 1710 writer->WriteTag(is_const_ ? kConstConstructorInvocation |
| 1711 : kConstructorInvocation); |
| 1712 writer->WriteUInt(0); |
| 1713 Reference::WriteMemberTo(writer, target_); |
| 1714 arguments_->WriteTo(writer); |
| 1715 } |
| 1716 |
| 1717 |
| 1718 Not* Not::ReadFrom(Reader* reader) { |
| 1719 TRACE_READ_OFFSET(); |
| 1720 Not* n = new Not(); |
| 1721 n->expression_ = Expression::ReadFrom(reader); |
| 1722 return n; |
| 1723 } |
| 1724 |
| 1725 |
| 1726 void Not::WriteTo(Writer* writer) { |
| 1727 TRACE_WRITE_OFFSET(); |
| 1728 writer->WriteTag(kNot); |
| 1729 expression_->WriteTo(writer); |
| 1730 } |
| 1731 |
| 1732 |
| 1733 LogicalExpression* LogicalExpression::ReadFrom(Reader* reader) { |
| 1734 TRACE_READ_OFFSET(); |
| 1735 LogicalExpression* expr = new LogicalExpression(); |
| 1736 expr->left_ = Expression::ReadFrom(reader); |
| 1737 expr->operator_ = static_cast<Operator>(reader->ReadByte()); |
| 1738 expr->right_ = Expression::ReadFrom(reader); |
| 1739 return expr; |
| 1740 } |
| 1741 |
| 1742 |
| 1743 void LogicalExpression::WriteTo(Writer* writer) { |
| 1744 TRACE_WRITE_OFFSET(); |
| 1745 writer->WriteTag(kLogicalExpression); |
| 1746 left_->WriteTo(writer); |
| 1747 writer->WriteByte(operator_); |
| 1748 right_->WriteTo(writer); |
| 1749 } |
| 1750 |
| 1751 |
| 1752 ConditionalExpression* ConditionalExpression::ReadFrom(Reader* reader) { |
| 1753 TRACE_READ_OFFSET(); |
| 1754 ConditionalExpression* expr = new ConditionalExpression(); |
| 1755 expr->condition_ = Expression::ReadFrom(reader); |
| 1756 expr->then_ = Expression::ReadFrom(reader); |
| 1757 expr->otherwise_ = Expression::ReadFrom(reader); |
| 1758 reader->ReadOptional<DartType>(); // Unused static type. |
| 1759 return expr; |
| 1760 } |
| 1761 |
| 1762 |
| 1763 void ConditionalExpression::WriteTo(Writer* writer) { |
| 1764 TRACE_WRITE_OFFSET(); |
| 1765 writer->WriteTag(kConditionalExpression); |
| 1766 condition_->WriteTo(writer); |
| 1767 then_->WriteTo(writer); |
| 1768 otherwise_->WriteTo(writer); |
| 1769 writer->WriteOptional<DartType>(NULL); // Unused static type. |
| 1770 } |
| 1771 |
| 1772 |
| 1773 StringConcatenation* StringConcatenation::ReadFrom(Reader* reader) { |
| 1774 TRACE_READ_OFFSET(); |
| 1775 StringConcatenation* concat = new StringConcatenation(); |
| 1776 concat->expressions_.ReadFromStatic<Expression>(reader); |
| 1777 return concat; |
| 1778 } |
| 1779 |
| 1780 |
| 1781 void StringConcatenation::WriteTo(Writer* writer) { |
| 1782 TRACE_WRITE_OFFSET(); |
| 1783 writer->WriteTag(kStringConcatenation); |
| 1784 expressions_.WriteTo(writer); |
| 1785 } |
| 1786 |
| 1787 |
| 1788 IsExpression* IsExpression::ReadFrom(Reader* reader) { |
| 1789 TRACE_READ_OFFSET(); |
| 1790 IsExpression* expr = new IsExpression(); |
| 1791 expr->operand_ = Expression::ReadFrom(reader); |
| 1792 expr->type_ = DartType::ReadFrom(reader); |
| 1793 return expr; |
| 1794 } |
| 1795 |
| 1796 |
| 1797 void IsExpression::WriteTo(Writer* writer) { |
| 1798 TRACE_WRITE_OFFSET(); |
| 1799 writer->WriteTag(kIsExpression); |
| 1800 operand_->WriteTo(writer); |
| 1801 type_->WriteTo(writer); |
| 1802 } |
| 1803 |
| 1804 |
| 1805 AsExpression* AsExpression::ReadFrom(Reader* reader) { |
| 1806 TRACE_READ_OFFSET(); |
| 1807 AsExpression* expr = new AsExpression(); |
| 1808 expr->operand_ = Expression::ReadFrom(reader); |
| 1809 expr->type_ = DartType::ReadFrom(reader); |
| 1810 return expr; |
| 1811 } |
| 1812 |
| 1813 |
| 1814 void AsExpression::WriteTo(Writer* writer) { |
| 1815 TRACE_WRITE_OFFSET(); |
| 1816 writer->WriteTag(kAsExpression); |
| 1817 operand_->WriteTo(writer); |
| 1818 type_->WriteTo(writer); |
| 1819 } |
| 1820 |
| 1821 |
| 1822 StringLiteral* StringLiteral::ReadFrom(Reader* reader) { |
| 1823 TRACE_READ_OFFSET(); |
| 1824 return new StringLiteral(Reference::ReadStringFrom(reader)); |
| 1825 } |
| 1826 |
| 1827 |
| 1828 void StringLiteral::WriteTo(Writer* writer) { |
| 1829 TRACE_WRITE_OFFSET(); |
| 1830 writer->WriteTag(kStringLiteral); |
| 1831 value_->WriteTo(writer); |
| 1832 } |
| 1833 |
| 1834 |
| 1835 BigintLiteral* BigintLiteral::ReadFrom(Reader* reader) { |
| 1836 TRACE_READ_OFFSET(); |
| 1837 return new BigintLiteral(Reference::ReadStringFrom(reader)); |
| 1838 } |
| 1839 |
| 1840 |
| 1841 void BigintLiteral::WriteTo(Writer* writer) { |
| 1842 TRACE_WRITE_OFFSET(); |
| 1843 writer->WriteTag(kBigIntLiteral); |
| 1844 value_->WriteTo(writer); |
| 1845 } |
| 1846 |
| 1847 |
| 1848 IntLiteral* IntLiteral::ReadFrom(Reader* reader, bool is_negative) { |
| 1849 TRACE_READ_OFFSET(); |
| 1850 IntLiteral* literal = new IntLiteral(); |
| 1851 literal->value_ = is_negative ? -static_cast<int64_t>(reader->ReadUInt()) |
| 1852 : reader->ReadUInt(); |
| 1853 return literal; |
| 1854 } |
| 1855 |
| 1856 |
| 1857 IntLiteral* IntLiteral::ReadFrom(Reader* reader, uint8_t payload) { |
| 1858 TRACE_READ_OFFSET(); |
| 1859 IntLiteral* literal = new IntLiteral(); |
| 1860 literal->value_ = static_cast<int32_t>(payload) - SpecializedIntLiteralBias; |
| 1861 return literal; |
| 1862 } |
| 1863 |
| 1864 |
| 1865 void IntLiteral::WriteTo(Writer* writer) { |
| 1866 TRACE_WRITE_OFFSET(); |
| 1867 int64_t payload = value_ + SpecializedIntLiteralBias; |
| 1868 if ((payload & kSpecializedPayloadMask) == payload) { |
| 1869 writer->WriteTag(kSpecialIntLiteral, static_cast<uint8_t>(payload)); |
| 1870 } else { |
| 1871 writer->WriteTag(value_ < 0 ? kNegativeIntLiteral : kPositiveIntLiteral); |
| 1872 writer->WriteUInt(static_cast<uint32_t>(value_ < 0 ? -value_ : value_)); |
| 1873 } |
| 1874 } |
| 1875 |
| 1876 |
| 1877 DoubleLiteral* DoubleLiteral::ReadFrom(Reader* reader) { |
| 1878 TRACE_READ_OFFSET(); |
| 1879 DoubleLiteral* literal = new DoubleLiteral(); |
| 1880 literal->value_ = Reference::ReadStringFrom(reader); |
| 1881 return literal; |
| 1882 } |
| 1883 |
| 1884 |
| 1885 void DoubleLiteral::WriteTo(Writer* writer) { |
| 1886 TRACE_WRITE_OFFSET(); |
| 1887 writer->WriteTag(kDoubleLiteral); |
| 1888 value_->WriteTo(writer); |
| 1889 } |
| 1890 |
| 1891 |
| 1892 BoolLiteral* BoolLiteral::ReadFrom(Reader* reader, bool value) { |
| 1893 TRACE_READ_OFFSET(); |
| 1894 BoolLiteral* lit = new BoolLiteral(); |
| 1895 lit->value_ = value; |
| 1896 return lit; |
| 1897 } |
| 1898 |
| 1899 |
| 1900 void BoolLiteral::WriteTo(Writer* writer) { |
| 1901 TRACE_WRITE_OFFSET(); |
| 1902 writer->WriteTag(value_ ? kTrueLiteral : kFalseLiteral); |
| 1903 } |
| 1904 |
| 1905 |
| 1906 NullLiteral* NullLiteral::ReadFrom(Reader* reader) { |
| 1907 TRACE_READ_OFFSET(); |
| 1908 return new NullLiteral(); |
| 1909 } |
| 1910 |
| 1911 |
| 1912 void NullLiteral::WriteTo(Writer* writer) { |
| 1913 TRACE_WRITE_OFFSET(); |
| 1914 writer->WriteTag(kNullLiteral); |
| 1915 } |
| 1916 |
| 1917 |
| 1918 SymbolLiteral* SymbolLiteral::ReadFrom(Reader* reader) { |
| 1919 TRACE_READ_OFFSET(); |
| 1920 SymbolLiteral* lit = new SymbolLiteral(); |
| 1921 lit->value_ = Reference::ReadStringFrom(reader); |
| 1922 return lit; |
| 1923 } |
| 1924 |
| 1925 |
| 1926 void SymbolLiteral::WriteTo(Writer* writer) { |
| 1927 TRACE_WRITE_OFFSET(); |
| 1928 writer->WriteTag(kSymbolLiteral); |
| 1929 value_->WriteTo(writer); |
| 1930 } |
| 1931 |
| 1932 |
| 1933 TypeLiteral* TypeLiteral::ReadFrom(Reader* reader) { |
| 1934 TRACE_READ_OFFSET(); |
| 1935 TypeLiteral* literal = new TypeLiteral(); |
| 1936 literal->type_ = DartType::ReadFrom(reader); |
| 1937 return literal; |
| 1938 } |
| 1939 |
| 1940 |
| 1941 void TypeLiteral::WriteTo(Writer* writer) { |
| 1942 TRACE_WRITE_OFFSET(); |
| 1943 writer->WriteTag(kTypeLiteral); |
| 1944 type_->WriteTo(writer); |
| 1945 } |
| 1946 |
| 1947 |
| 1948 ThisExpression* ThisExpression::ReadFrom(Reader* reader) { |
| 1949 TRACE_READ_OFFSET(); |
| 1950 return new ThisExpression(); |
| 1951 } |
| 1952 |
| 1953 |
| 1954 void ThisExpression::WriteTo(Writer* writer) { |
| 1955 TRACE_WRITE_OFFSET(); |
| 1956 writer->WriteTag(kThisExpression); |
| 1957 } |
| 1958 |
| 1959 |
| 1960 Rethrow* Rethrow::ReadFrom(Reader* reader) { |
| 1961 TRACE_READ_OFFSET(); |
| 1962 return new Rethrow(); |
| 1963 } |
| 1964 |
| 1965 |
| 1966 void Rethrow::WriteTo(Writer* writer) { |
| 1967 TRACE_WRITE_OFFSET(); |
| 1968 writer->WriteTag(kRethrow); |
| 1969 } |
| 1970 |
| 1971 |
| 1972 Throw* Throw::ReadFrom(Reader* reader) { |
| 1973 TRACE_READ_OFFSET(); |
| 1974 Throw* t = new Throw(); |
| 1975 reader->ReadUInt(); |
| 1976 t->expression_ = Expression::ReadFrom(reader); |
| 1977 return t; |
| 1978 } |
| 1979 |
| 1980 |
| 1981 void Throw::WriteTo(Writer* writer) { |
| 1982 TRACE_WRITE_OFFSET(); |
| 1983 writer->WriteTag(kThrow); |
| 1984 writer->WriteUInt(0); |
| 1985 expression_->WriteTo(writer); |
| 1986 } |
| 1987 |
| 1988 |
| 1989 ListLiteral* ListLiteral::ReadFrom(Reader* reader, bool is_const) { |
| 1990 TRACE_READ_OFFSET(); |
| 1991 ListLiteral* literal = new ListLiteral(); |
| 1992 literal->is_const_ = is_const; |
| 1993 literal->type_ = DartType::ReadFrom(reader); |
| 1994 literal->expressions_.ReadFromStatic<Expression>(reader); |
| 1995 return literal; |
| 1996 } |
| 1997 |
| 1998 |
| 1999 void ListLiteral::WriteTo(Writer* writer) { |
| 2000 TRACE_WRITE_OFFSET(); |
| 2001 writer->WriteTag(is_const_ ? kConstListLiteral : kListLiteral); |
| 2002 type_->WriteTo(writer); |
| 2003 expressions_.WriteTo(writer); |
| 2004 } |
| 2005 |
| 2006 |
| 2007 MapLiteral* MapLiteral::ReadFrom(Reader* reader, bool is_const) { |
| 2008 TRACE_READ_OFFSET(); |
| 2009 MapLiteral* literal = new MapLiteral(); |
| 2010 literal->is_const_ = is_const; |
| 2011 literal->key_type_ = DartType::ReadFrom(reader); |
| 2012 literal->value_type_ = DartType::ReadFrom(reader); |
| 2013 literal->entries_.ReadFromStatic<MapEntry>(reader); |
| 2014 return literal; |
| 2015 } |
| 2016 |
| 2017 |
| 2018 void MapLiteral::WriteTo(Writer* writer) { |
| 2019 TRACE_WRITE_OFFSET(); |
| 2020 writer->WriteTag(is_const_ ? kConstMapLiteral : kMapLiteral); |
| 2021 key_type_->WriteTo(writer); |
| 2022 value_type_->WriteTo(writer); |
| 2023 entries_.WriteTo(writer); |
| 2024 } |
| 2025 |
| 2026 |
| 2027 MapEntry* MapEntry::ReadFrom(Reader* reader) { |
| 2028 MapEntry* entry = new MapEntry(); |
| 2029 entry->key_ = Expression::ReadFrom(reader); |
| 2030 entry->value_ = Expression::ReadFrom(reader); |
| 2031 return entry; |
| 2032 } |
| 2033 |
| 2034 |
| 2035 void MapEntry::WriteTo(Writer* writer) { |
| 2036 TRACE_WRITE_OFFSET(); |
| 2037 key_->WriteTo(writer); |
| 2038 value_->WriteTo(writer); |
| 2039 } |
| 2040 |
| 2041 |
| 2042 AwaitExpression* AwaitExpression::ReadFrom(Reader* reader) { |
| 2043 TRACE_READ_OFFSET(); |
| 2044 AwaitExpression* await = new AwaitExpression(); |
| 2045 await->operand_ = Expression::ReadFrom(reader); |
| 2046 return await; |
| 2047 } |
| 2048 |
| 2049 |
| 2050 void AwaitExpression::WriteTo(Writer* writer) { |
| 2051 TRACE_WRITE_OFFSET(); |
| 2052 writer->WriteTag(kAwaitExpression); |
| 2053 operand_->WriteTo(writer); |
| 2054 } |
| 2055 |
| 2056 |
| 2057 FunctionExpression* FunctionExpression::ReadFrom(Reader* reader) { |
| 2058 TRACE_READ_OFFSET(); |
| 2059 VariableScope<ReaderHelper> parameters(reader->helper()); |
| 2060 FunctionExpression* expr = new FunctionExpression(); |
| 2061 expr->function_ = FunctionNode::ReadFrom(reader); |
| 2062 return expr; |
| 2063 } |
| 2064 |
| 2065 |
| 2066 void FunctionExpression::WriteTo(Writer* writer) { |
| 2067 TRACE_WRITE_OFFSET(); |
| 2068 VariableScope<WriterHelper> parameters(writer->helper()); |
| 2069 writer->WriteTag(kFunctionExpression); |
| 2070 function_->WriteTo(writer); |
| 2071 } |
| 2072 |
| 2073 |
| 2074 Let* Let::ReadFrom(Reader* reader) { |
| 2075 TRACE_READ_OFFSET(); |
| 2076 VariableScope<ReaderHelper> vars(reader->helper()); |
| 2077 Let* let = new Let(); |
| 2078 let->variable_ = VariableDeclaration::ReadFromImpl(reader); |
| 2079 let->body_ = Expression::ReadFrom(reader); |
| 2080 return let; |
| 2081 } |
| 2082 |
| 2083 |
| 2084 void Let::WriteTo(Writer* writer) { |
| 2085 TRACE_WRITE_OFFSET(); |
| 2086 VariableScope<WriterHelper> vars(writer->helper()); |
| 2087 writer->WriteTag(kLet); |
| 2088 variable_->WriteToImpl(writer); |
| 2089 body_->WriteTo(writer); |
| 2090 } |
| 2091 |
| 2092 |
| 2093 BlockExpression* BlockExpression::ReadFrom(Reader* reader) { |
| 2094 TRACE_READ_OFFSET(); |
| 2095 BlockExpression* be = new BlockExpression(); |
| 2096 be->body_ = Block::ReadFromImpl(reader); |
| 2097 be->value_ = Expression::ReadFrom(reader); |
| 2098 return be; |
| 2099 } |
| 2100 |
| 2101 |
| 2102 void BlockExpression::WriteTo(Writer* writer) { |
| 2103 TRACE_WRITE_OFFSET(); |
| 2104 writer->WriteTag(kBlockExpression); |
| 2105 body_->WriteToImpl(writer); |
| 2106 value_->WriteTo(writer); |
| 2107 } |
| 2108 |
| 2109 |
| 2110 Statement* Statement::ReadFrom(Reader* reader) { |
| 2111 TRACE_READ_OFFSET(); |
| 2112 Tag tag = reader->ReadTag(); |
| 2113 switch (tag) { |
| 2114 case kInvalidStatement: |
| 2115 return InvalidStatement::ReadFrom(reader); |
| 2116 case kExpressionStatement: |
| 2117 return ExpressionStatement::ReadFrom(reader); |
| 2118 case kBlock: |
| 2119 return Block::ReadFromImpl(reader); |
| 2120 case kEmptyStatement: |
| 2121 return EmptyStatement::ReadFrom(reader); |
| 2122 case kAssertStatement: |
| 2123 return AssertStatement::ReadFrom(reader); |
| 2124 case kLabeledStatement: |
| 2125 return LabeledStatement::ReadFrom(reader); |
| 2126 case kBreakStatement: |
| 2127 return BreakStatement::ReadFrom(reader); |
| 2128 case kWhileStatement: |
| 2129 return WhileStatement::ReadFrom(reader); |
| 2130 case kDoStatement: |
| 2131 return DoStatement::ReadFrom(reader); |
| 2132 case kForStatement: |
| 2133 return ForStatement::ReadFrom(reader); |
| 2134 case kForInStatement: |
| 2135 return ForInStatement::ReadFrom(reader, false); |
| 2136 case kAsyncForInStatement: |
| 2137 return ForInStatement::ReadFrom(reader, true); |
| 2138 case kSwitchStatement: |
| 2139 return SwitchStatement::ReadFrom(reader); |
| 2140 case kContinueSwitchStatement: |
| 2141 return ContinueSwitchStatement::ReadFrom(reader); |
| 2142 case kIfStatement: |
| 2143 return IfStatement::ReadFrom(reader); |
| 2144 case kReturnStatement: |
| 2145 return ReturnStatement::ReadFrom(reader); |
| 2146 case kTryCatch: |
| 2147 return TryCatch::ReadFrom(reader); |
| 2148 case kTryFinally: |
| 2149 return TryFinally::ReadFrom(reader); |
| 2150 case kYieldStatement: |
| 2151 return YieldStatement::ReadFrom(reader); |
| 2152 case kVariableDeclaration: |
| 2153 return VariableDeclaration::ReadFromImpl(reader); |
| 2154 case kFunctionDeclaration: |
| 2155 return FunctionDeclaration::ReadFrom(reader); |
| 2156 default: |
| 2157 UNREACHABLE(); |
| 2158 } |
| 2159 return NULL; |
| 2160 } |
| 2161 |
| 2162 |
| 2163 InvalidStatement* InvalidStatement::ReadFrom(Reader* reader) { |
| 2164 TRACE_READ_OFFSET(); |
| 2165 return new InvalidStatement(); |
| 2166 } |
| 2167 |
| 2168 |
| 2169 void InvalidStatement::WriteTo(Writer* writer) { |
| 2170 TRACE_WRITE_OFFSET(); |
| 2171 writer->WriteTag(kInvalidStatement); |
| 2172 } |
| 2173 |
| 2174 |
| 2175 ExpressionStatement* ExpressionStatement::ReadFrom(Reader* reader) { |
| 2176 TRACE_READ_OFFSET(); |
| 2177 return new ExpressionStatement(Expression::ReadFrom(reader)); |
| 2178 } |
| 2179 |
| 2180 |
| 2181 void ExpressionStatement::WriteTo(Writer* writer) { |
| 2182 TRACE_WRITE_OFFSET(); |
| 2183 writer->WriteTag(kExpressionStatement); |
| 2184 expression_->WriteTo(writer); |
| 2185 } |
| 2186 |
| 2187 |
| 2188 Block* Block::ReadFromImpl(Reader* reader) { |
| 2189 TRACE_READ_OFFSET(); |
| 2190 VariableScope<ReaderHelper> vars(reader->helper()); |
| 2191 Block* block = new Block(); |
| 2192 block->statements().ReadFromStatic<Statement>(reader); |
| 2193 return block; |
| 2194 } |
| 2195 |
| 2196 |
| 2197 void Block::WriteTo(Writer* writer) { |
| 2198 writer->WriteTag(kBlock); |
| 2199 WriteToImpl(writer); |
| 2200 } |
| 2201 |
| 2202 |
| 2203 void Block::WriteToImpl(Writer* writer) { |
| 2204 TRACE_WRITE_OFFSET(); |
| 2205 VariableScope<WriterHelper> vars(writer->helper()); |
| 2206 statements_.WriteTo(writer); |
| 2207 } |
| 2208 |
| 2209 |
| 2210 EmptyStatement* EmptyStatement::ReadFrom(Reader* reader) { |
| 2211 TRACE_READ_OFFSET(); |
| 2212 return new EmptyStatement(); |
| 2213 } |
| 2214 |
| 2215 |
| 2216 void EmptyStatement::WriteTo(Writer* writer) { |
| 2217 TRACE_WRITE_OFFSET(); |
| 2218 writer->WriteTag(kEmptyStatement); |
| 2219 } |
| 2220 |
| 2221 |
| 2222 AssertStatement* AssertStatement::ReadFrom(Reader* reader) { |
| 2223 TRACE_READ_OFFSET(); |
| 2224 AssertStatement* stmt = new AssertStatement(); |
| 2225 stmt->condition_ = Expression::ReadFrom(reader); |
| 2226 stmt->message_ = reader->ReadOptional<Expression>(); |
| 2227 return stmt; |
| 2228 } |
| 2229 |
| 2230 |
| 2231 void AssertStatement::WriteTo(Writer* writer) { |
| 2232 TRACE_WRITE_OFFSET(); |
| 2233 writer->WriteTag(kAssertStatement); |
| 2234 condition_->WriteTo(writer); |
| 2235 writer->WriteOptional<Expression>(message_); |
| 2236 } |
| 2237 |
| 2238 |
| 2239 LabeledStatement* LabeledStatement::ReadFrom(Reader* reader) { |
| 2240 TRACE_READ_OFFSET(); |
| 2241 LabeledStatement* stmt = new LabeledStatement(); |
| 2242 reader->helper()->lables().Push(stmt); |
| 2243 stmt->body_ = Statement::ReadFrom(reader); |
| 2244 reader->helper()->lables().Pop(stmt); |
| 2245 return stmt; |
| 2246 } |
| 2247 |
| 2248 |
| 2249 void LabeledStatement::WriteTo(Writer* writer) { |
| 2250 TRACE_WRITE_OFFSET(); |
| 2251 writer->WriteTag(kLabeledStatement); |
| 2252 writer->helper()->lables().Push(this); |
| 2253 body_->WriteTo(writer); |
| 2254 writer->helper()->lables().Pop(this); |
| 2255 } |
| 2256 |
| 2257 |
| 2258 BreakStatement* BreakStatement::ReadFrom(Reader* reader) { |
| 2259 TRACE_READ_OFFSET(); |
| 2260 BreakStatement* stmt = new BreakStatement(); |
| 2261 stmt->target_ = reader->helper()->lables().Lookup(reader->ReadUInt()); |
| 2262 return stmt; |
| 2263 } |
| 2264 |
| 2265 |
| 2266 void BreakStatement::WriteTo(Writer* writer) { |
| 2267 TRACE_WRITE_OFFSET(); |
| 2268 writer->WriteTag(kBreakStatement); |
| 2269 writer->WriteUInt(writer->helper()->lables().Lookup(target_)); |
| 2270 } |
| 2271 |
| 2272 |
| 2273 WhileStatement* WhileStatement::ReadFrom(Reader* reader) { |
| 2274 TRACE_READ_OFFSET(); |
| 2275 WhileStatement* stmt = new WhileStatement(); |
| 2276 stmt->condition_ = Expression::ReadFrom(reader); |
| 2277 stmt->body_ = Statement::ReadFrom(reader); |
| 2278 return stmt; |
| 2279 } |
| 2280 |
| 2281 |
| 2282 void WhileStatement::WriteTo(Writer* writer) { |
| 2283 TRACE_WRITE_OFFSET(); |
| 2284 writer->WriteTag(kWhileStatement); |
| 2285 condition_->WriteTo(writer); |
| 2286 body_->WriteTo(writer); |
| 2287 } |
| 2288 |
| 2289 |
| 2290 DoStatement* DoStatement::ReadFrom(Reader* reader) { |
| 2291 TRACE_READ_OFFSET(); |
| 2292 DoStatement* dostmt = new DoStatement(); |
| 2293 dostmt->body_ = Statement::ReadFrom(reader); |
| 2294 dostmt->condition_ = Expression::ReadFrom(reader); |
| 2295 return dostmt; |
| 2296 } |
| 2297 |
| 2298 |
| 2299 void DoStatement::WriteTo(Writer* writer) { |
| 2300 TRACE_WRITE_OFFSET(); |
| 2301 writer->WriteTag(kDoStatement); |
| 2302 body_->WriteTo(writer); |
| 2303 condition_->WriteTo(writer); |
| 2304 } |
| 2305 |
| 2306 |
| 2307 ForStatement* ForStatement::ReadFrom(Reader* reader) { |
| 2308 TRACE_READ_OFFSET(); |
| 2309 VariableScope<ReaderHelper> vars(reader->helper()); |
| 2310 ForStatement* forstmt = new ForStatement(); |
| 2311 forstmt->variables_.ReadFromStatic<VariableDeclarationImpl>(reader); |
| 2312 forstmt->condition_ = reader->ReadOptional<Expression>(); |
| 2313 forstmt->updates_.ReadFromStatic<Expression>(reader); |
| 2314 forstmt->body_ = Statement::ReadFrom(reader); |
| 2315 return forstmt; |
| 2316 } |
| 2317 |
| 2318 |
| 2319 void ForStatement::WriteTo(Writer* writer) { |
| 2320 TRACE_WRITE_OFFSET(); |
| 2321 writer->WriteTag(kForStatement); |
| 2322 VariableScope<WriterHelper> vars(writer->helper()); |
| 2323 variables_.WriteToStatic<VariableDeclarationImpl>(writer); |
| 2324 writer->WriteOptional<Expression>(condition_); |
| 2325 updates_.WriteTo(writer); |
| 2326 body_->WriteTo(writer); |
| 2327 } |
| 2328 |
| 2329 |
| 2330 ForInStatement* ForInStatement::ReadFrom(Reader* reader, bool is_async) { |
| 2331 TRACE_READ_OFFSET(); |
| 2332 VariableScope<ReaderHelper> vars(reader->helper()); |
| 2333 ForInStatement* forinstmt = new ForInStatement(); |
| 2334 forinstmt->is_async_ = is_async; |
| 2335 forinstmt->variable_ = VariableDeclaration::ReadFromImpl(reader); |
| 2336 forinstmt->iterable_ = Expression::ReadFrom(reader); |
| 2337 forinstmt->body_ = Statement::ReadFrom(reader); |
| 2338 return forinstmt; |
| 2339 } |
| 2340 |
| 2341 |
| 2342 void ForInStatement::WriteTo(Writer* writer) { |
| 2343 TRACE_WRITE_OFFSET(); |
| 2344 writer->WriteTag(is_async_ ? kAsyncForInStatement : kForInStatement); |
| 2345 VariableScope<WriterHelper> vars(writer->helper()); |
| 2346 variable_->WriteToImpl(writer); |
| 2347 iterable_->WriteTo(writer); |
| 2348 body_->WriteTo(writer); |
| 2349 } |
| 2350 |
| 2351 |
| 2352 SwitchStatement* SwitchStatement::ReadFrom(Reader* reader) { |
| 2353 TRACE_READ_OFFSET(); |
| 2354 SwitchCaseScope<ReaderHelper> scope(reader->helper()); |
| 2355 SwitchStatement* stmt = new SwitchStatement(); |
| 2356 stmt->condition_ = Expression::ReadFrom(reader); |
| 2357 // We need to explicitly create empty [SwitchCase]s first in order to add them |
| 2358 // to the [SwitchCaseScope]. This is necessary since a [Statement] in a switch |
| 2359 // case can refer to one defined later on. |
| 2360 int count = reader->ReadUInt(); |
| 2361 for (int i = 0; i < count; i++) { |
| 2362 SwitchCase* sc = stmt->cases_.GetOrCreate<SwitchCase>(i); |
| 2363 reader->helper()->switch_cases().Push(sc); |
| 2364 } |
| 2365 for (int i = 0; i < count; i++) { |
| 2366 SwitchCase* sc = stmt->cases_[i]; |
| 2367 sc->ReadFrom(reader); |
| 2368 } |
| 2369 return stmt; |
| 2370 } |
| 2371 |
| 2372 |
| 2373 void SwitchStatement::WriteTo(Writer* writer) { |
| 2374 TRACE_WRITE_OFFSET(); |
| 2375 SwitchCaseScope<WriterHelper> scope(writer->helper()); |
| 2376 writer->WriteTag(kSwitchStatement); |
| 2377 condition_->WriteTo(writer); |
| 2378 for (int i = 0; i < cases_.length(); i++) { |
| 2379 writer->helper()->switch_cases().Push(cases_[i]); |
| 2380 } |
| 2381 cases_.WriteTo(writer); |
| 2382 } |
| 2383 |
| 2384 |
| 2385 SwitchCase* SwitchCase::ReadFrom(Reader* reader) { |
| 2386 TRACE_READ_OFFSET(); |
| 2387 expressions_.ReadFromStatic<Expression>(reader); |
| 2388 is_default_ = reader->ReadBool(); |
| 2389 body_ = Statement::ReadFrom(reader); |
| 2390 return this; |
| 2391 } |
| 2392 |
| 2393 |
| 2394 void SwitchCase::WriteTo(Writer* writer) { |
| 2395 TRACE_WRITE_OFFSET(); |
| 2396 expressions_.WriteTo(writer); |
| 2397 writer->WriteBool(is_default_); |
| 2398 body_->WriteTo(writer); |
| 2399 } |
| 2400 |
| 2401 |
| 2402 ContinueSwitchStatement* ContinueSwitchStatement::ReadFrom(Reader* reader) { |
| 2403 TRACE_READ_OFFSET(); |
| 2404 ContinueSwitchStatement* stmt = new ContinueSwitchStatement(); |
| 2405 stmt->target_ = reader->helper()->switch_cases().Lookup(reader->ReadUInt()); |
| 2406 return stmt; |
| 2407 } |
| 2408 |
| 2409 |
| 2410 void ContinueSwitchStatement::WriteTo(Writer* writer) { |
| 2411 TRACE_WRITE_OFFSET(); |
| 2412 writer->WriteTag(kContinueSwitchStatement); |
| 2413 writer->WriteUInt(writer->helper()->switch_cases().Lookup(target_)); |
| 2414 } |
| 2415 |
| 2416 |
| 2417 IfStatement* IfStatement::ReadFrom(Reader* reader) { |
| 2418 TRACE_READ_OFFSET(); |
| 2419 IfStatement* ifstmt = new IfStatement(); |
| 2420 ifstmt->condition_ = Expression::ReadFrom(reader); |
| 2421 ifstmt->then_ = Statement::ReadFrom(reader); |
| 2422 ifstmt->otherwise_ = Statement::ReadFrom(reader); |
| 2423 return ifstmt; |
| 2424 } |
| 2425 |
| 2426 |
| 2427 void IfStatement::WriteTo(Writer* writer) { |
| 2428 TRACE_WRITE_OFFSET(); |
| 2429 writer->WriteTag(kIfStatement); |
| 2430 condition_->WriteTo(writer); |
| 2431 then_->WriteTo(writer); |
| 2432 otherwise_->WriteTo(writer); |
| 2433 } |
| 2434 |
| 2435 |
| 2436 ReturnStatement* ReturnStatement::ReadFrom(Reader* reader) { |
| 2437 TRACE_READ_OFFSET(); |
| 2438 ReturnStatement* ret = new ReturnStatement(); |
| 2439 ret->expression_ = reader->ReadOptional<Expression>(); |
| 2440 return ret; |
| 2441 } |
| 2442 |
| 2443 |
| 2444 void ReturnStatement::WriteTo(Writer* writer) { |
| 2445 TRACE_WRITE_OFFSET(); |
| 2446 writer->WriteTag(kReturnStatement); |
| 2447 writer->WriteOptional<Expression>(expression_); |
| 2448 } |
| 2449 |
| 2450 |
| 2451 TryCatch* TryCatch::ReadFrom(Reader* reader) { |
| 2452 TRACE_READ_OFFSET(); |
| 2453 TryCatch* tc = new TryCatch(); |
| 2454 tc->body_ = Statement::ReadFrom(reader); |
| 2455 tc->catches_.ReadFromStatic<Catch>(reader); |
| 2456 return tc; |
| 2457 } |
| 2458 |
| 2459 |
| 2460 void TryCatch::WriteTo(Writer* writer) { |
| 2461 TRACE_WRITE_OFFSET(); |
| 2462 writer->WriteTag(kTryCatch); |
| 2463 body_->WriteTo(writer); |
| 2464 catches_.WriteTo(writer); |
| 2465 } |
| 2466 |
| 2467 |
| 2468 Catch* Catch::ReadFrom(Reader* reader) { |
| 2469 TRACE_READ_OFFSET(); |
| 2470 VariableScope<ReaderHelper> vars(reader->helper()); |
| 2471 Catch* c = new Catch(); |
| 2472 c->guard_ = DartType::ReadFrom(reader); |
| 2473 c->exception_ = |
| 2474 reader->ReadOptional<VariableDeclaration, VariableDeclarationImpl>(); |
| 2475 c->stack_trace_ = |
| 2476 reader->ReadOptional<VariableDeclaration, VariableDeclarationImpl>(); |
| 2477 c->body_ = Statement::ReadFrom(reader); |
| 2478 return c; |
| 2479 } |
| 2480 |
| 2481 |
| 2482 void Catch::WriteTo(Writer* writer) { |
| 2483 TRACE_WRITE_OFFSET(); |
| 2484 VariableScope<WriterHelper> vars(writer->helper()); |
| 2485 guard_->WriteTo(writer); |
| 2486 writer->WriteOptionalStatic<VariableDeclaration, VariableDeclarationImpl>( |
| 2487 exception_); |
| 2488 writer->WriteOptionalStatic<VariableDeclaration, VariableDeclarationImpl>( |
| 2489 stack_trace_); |
| 2490 body_->WriteTo(writer); |
| 2491 } |
| 2492 |
| 2493 |
| 2494 TryFinally* TryFinally::ReadFrom(Reader* reader) { |
| 2495 TRACE_READ_OFFSET(); |
| 2496 TryFinally* tf = new TryFinally(); |
| 2497 tf->body_ = Statement::ReadFrom(reader); |
| 2498 tf->finalizer_ = Statement::ReadFrom(reader); |
| 2499 return tf; |
| 2500 } |
| 2501 |
| 2502 |
| 2503 void TryFinally::WriteTo(Writer* writer) { |
| 2504 TRACE_WRITE_OFFSET(); |
| 2505 writer->WriteTag(kTryFinally); |
| 2506 body_->WriteTo(writer); |
| 2507 finalizer_->WriteTo(writer); |
| 2508 } |
| 2509 |
| 2510 |
| 2511 YieldStatement* YieldStatement::ReadFrom(Reader* reader) { |
| 2512 TRACE_READ_OFFSET(); |
| 2513 YieldStatement* stmt = new YieldStatement(); |
| 2514 stmt->flags_ = reader->ReadByte(); |
| 2515 stmt->expression_ = Expression::ReadFrom(reader); |
| 2516 return stmt; |
| 2517 } |
| 2518 |
| 2519 |
| 2520 void YieldStatement::WriteTo(Writer* writer) { |
| 2521 TRACE_WRITE_OFFSET(); |
| 2522 writer->WriteTag(kYieldStatement); |
| 2523 writer->WriteByte(flags_); |
| 2524 expression_->WriteTo(writer); |
| 2525 } |
| 2526 |
| 2527 |
| 2528 VariableDeclaration* VariableDeclaration::ReadFrom(Reader* reader) { |
| 2529 TRACE_READ_OFFSET(); |
| 2530 Tag tag = reader->ReadTag(); |
| 2531 ASSERT(tag == kVariableDeclaration); |
| 2532 return VariableDeclaration::ReadFromImpl(reader); |
| 2533 } |
| 2534 |
| 2535 |
| 2536 VariableDeclaration* VariableDeclaration::ReadFromImpl(Reader* reader) { |
| 2537 TRACE_READ_OFFSET(); |
| 2538 VariableDeclaration* decl = new VariableDeclaration(); |
| 2539 decl->flags_ = reader->ReadFlags(); |
| 2540 decl->name_ = Reference::ReadStringFrom(reader); |
| 2541 decl->type_ = DartType::ReadFrom(reader); |
| 2542 decl->inferred_value_ = reader->ReadOptional<InferredValue>(); |
| 2543 decl->initializer_ = reader->ReadOptional<Expression>(); |
| 2544 reader->helper()->variables().Push(decl); |
| 2545 return decl; |
| 2546 } |
| 2547 |
| 2548 |
| 2549 void VariableDeclaration::WriteTo(Writer* writer) { |
| 2550 TRACE_WRITE_OFFSET(); |
| 2551 writer->WriteTag(kVariableDeclaration); |
| 2552 WriteToImpl(writer); |
| 2553 } |
| 2554 |
| 2555 |
| 2556 void VariableDeclaration::WriteToImpl(Writer* writer) { |
| 2557 TRACE_WRITE_OFFSET(); |
| 2558 writer->WriteFlags(flags_); |
| 2559 name_->WriteTo(writer); |
| 2560 type_->WriteTo(writer); |
| 2561 writer->WriteOptional<InferredValue>(inferred_value_); |
| 2562 writer->WriteOptional<Expression>(initializer_); |
| 2563 writer->helper()->variables().Push(this); |
| 2564 } |
| 2565 |
| 2566 |
| 2567 FunctionDeclaration* FunctionDeclaration::ReadFrom(Reader* reader) { |
| 2568 TRACE_READ_OFFSET(); |
| 2569 FunctionDeclaration* decl = new FunctionDeclaration(); |
| 2570 decl->variable_ = VariableDeclaration::ReadFromImpl(reader); |
| 2571 VariableScope<ReaderHelper> parameters(reader->helper()); |
| 2572 decl->function_ = FunctionNode::ReadFrom(reader); |
| 2573 return decl; |
| 2574 } |
| 2575 |
| 2576 |
| 2577 void FunctionDeclaration::WriteTo(Writer* writer) { |
| 2578 TRACE_WRITE_OFFSET(); |
| 2579 writer->WriteTag(kFunctionDeclaration); |
| 2580 variable_->WriteToImpl(writer); |
| 2581 VariableScope<WriterHelper> parameters(writer->helper()); |
| 2582 function_->WriteTo(writer); |
| 2583 } |
| 2584 |
| 2585 |
| 2586 Name* Name::ReadFrom(Reader* reader) { |
| 2587 String* string = Reference::ReadStringFrom(reader); |
| 2588 if (string->size() >= 1 && string->buffer()[0] == '_') { |
| 2589 int lib_index = reader->ReadUInt(); |
| 2590 Library* library = |
| 2591 reader->helper()->program()->libraries().GetOrCreate<Library>( |
| 2592 lib_index); |
| 2593 return new Name(string, library); |
| 2594 } else { |
| 2595 return new Name(string, NULL); |
| 2596 } |
| 2597 } |
| 2598 |
| 2599 |
| 2600 void Name::WriteTo(Writer* writer) { |
| 2601 TRACE_WRITE_OFFSET(); |
| 2602 string_->WriteTo(writer); |
| 2603 Library* library = library_; |
| 2604 bool is_private = library != NULL; |
| 2605 if (is_private) { |
| 2606 writer->WriteUInt(writer->helper()->libraries().Lookup(library_)); |
| 2607 } |
| 2608 } |
| 2609 |
| 2610 |
| 2611 InferredValue* InferredValue::ReadFrom(Reader* reader) { |
| 2612 InferredValue* type = new InferredValue(); |
| 2613 type->klass_ = Reference::ReadClassFrom(reader, true); |
| 2614 type->kind_ = static_cast<BaseClassKind>(reader->ReadByte()); |
| 2615 type->value_bits_ = reader->ReadByte(); |
| 2616 return type; |
| 2617 } |
| 2618 |
| 2619 |
| 2620 void InferredValue::WriteTo(Writer* writer) { |
| 2621 Reference::WriteClassTo(writer, klass_, true); |
| 2622 writer->WriteByte(static_cast<uint8_t>(kind_)); |
| 2623 writer->WriteByte(value_bits_); |
| 2624 } |
| 2625 |
| 2626 |
| 2627 DartType* DartType::ReadFrom(Reader* reader) { |
| 2628 TRACE_READ_OFFSET(); |
| 2629 Tag tag = reader->ReadTag(); |
| 2630 switch (tag) { |
| 2631 case kInvalidType: |
| 2632 return InvalidType::ReadFrom(reader); |
| 2633 case kDynamicType: |
| 2634 return DynamicType::ReadFrom(reader); |
| 2635 case kVoidType: |
| 2636 return VoidType::ReadFrom(reader); |
| 2637 case kInterfaceType: |
| 2638 return InterfaceType::ReadFrom(reader); |
| 2639 case kSimpleInterfaceType: |
| 2640 return InterfaceType::ReadFrom(reader, true); |
| 2641 case kFunctionType: |
| 2642 return FunctionType::ReadFrom(reader); |
| 2643 case kSimpleFunctionType: |
| 2644 return FunctionType::ReadFrom(reader, true); |
| 2645 case kTypeParameterType: |
| 2646 return TypeParameterType::ReadFrom(reader); |
| 2647 default: |
| 2648 UNREACHABLE(); |
| 2649 } |
| 2650 UNREACHABLE(); |
| 2651 return NULL; |
| 2652 } |
| 2653 |
| 2654 |
| 2655 InvalidType* InvalidType::ReadFrom(Reader* reader) { |
| 2656 TRACE_READ_OFFSET(); |
| 2657 return new InvalidType(); |
| 2658 } |
| 2659 |
| 2660 |
| 2661 void InvalidType::WriteTo(Writer* writer) { |
| 2662 TRACE_WRITE_OFFSET(); |
| 2663 writer->WriteTag(kInvalidType); |
| 2664 } |
| 2665 |
| 2666 |
| 2667 DynamicType* DynamicType::ReadFrom(Reader* reader) { |
| 2668 TRACE_READ_OFFSET(); |
| 2669 return new DynamicType(); |
| 2670 } |
| 2671 |
| 2672 |
| 2673 void DynamicType::WriteTo(Writer* writer) { |
| 2674 TRACE_WRITE_OFFSET(); |
| 2675 writer->WriteTag(kDynamicType); |
| 2676 } |
| 2677 |
| 2678 |
| 2679 VoidType* VoidType::ReadFrom(Reader* reader) { |
| 2680 TRACE_READ_OFFSET(); |
| 2681 return new VoidType(); |
| 2682 } |
| 2683 |
| 2684 |
| 2685 void VoidType::WriteTo(Writer* writer) { |
| 2686 TRACE_WRITE_OFFSET(); |
| 2687 writer->WriteTag(kVoidType); |
| 2688 } |
| 2689 |
| 2690 |
| 2691 InterfaceType* InterfaceType::ReadFrom(Reader* reader) { |
| 2692 TRACE_READ_OFFSET(); |
| 2693 Class* klass = Reference::ReadClassFrom(reader); |
| 2694 InterfaceType* type = new InterfaceType(klass); |
| 2695 type->type_arguments().ReadFromStatic<DartType>(reader); |
| 2696 return type; |
| 2697 } |
| 2698 |
| 2699 |
| 2700 InterfaceType* InterfaceType::ReadFrom(Reader* reader, |
| 2701 bool _without_type_arguments_) { |
| 2702 TRACE_READ_OFFSET(); |
| 2703 Class* klass = Reference::ReadClassFrom(reader); |
| 2704 InterfaceType* type = new InterfaceType(klass); |
| 2705 ASSERT(_without_type_arguments_); |
| 2706 return type; |
| 2707 } |
| 2708 |
| 2709 |
| 2710 void InterfaceType::WriteTo(Writer* writer) { |
| 2711 TRACE_WRITE_OFFSET(); |
| 2712 if (type_arguments_.length() == 0) { |
| 2713 writer->WriteTag(kSimpleInterfaceType); |
| 2714 Reference::WriteClassTo(writer, klass_); |
| 2715 } else { |
| 2716 writer->WriteTag(kInterfaceType); |
| 2717 Reference::WriteClassTo(writer, klass_); |
| 2718 type_arguments_.WriteTo(writer); |
| 2719 } |
| 2720 } |
| 2721 |
| 2722 |
| 2723 FunctionType* FunctionType::ReadFrom(Reader* reader) { |
| 2724 TRACE_READ_OFFSET(); |
| 2725 FunctionType* type = new FunctionType(); |
| 2726 TypeParameterScope<ReaderHelper> scope(reader->helper()); |
| 2727 type->type_parameters().ReadFrom(reader); |
| 2728 type->required_parameter_count_ = reader->ReadUInt(); |
| 2729 type->positional_parameters().ReadFromStatic<DartType>(reader); |
| 2730 type->named_parameters().ReadFromStatic<Tuple<String, DartType> >(reader); |
| 2731 type->return_type_ = DartType::ReadFrom(reader); |
| 2732 return type; |
| 2733 } |
| 2734 |
| 2735 |
| 2736 FunctionType* FunctionType::ReadFrom(Reader* reader, bool _is_simple_) { |
| 2737 TRACE_READ_OFFSET(); |
| 2738 FunctionType* type = new FunctionType(); |
| 2739 ASSERT(_is_simple_); |
| 2740 type->positional_parameters().ReadFromStatic<DartType>(reader); |
| 2741 type->required_parameter_count_ = type->positional_parameters().length(); |
| 2742 type->return_type_ = DartType::ReadFrom(reader); |
| 2743 return type; |
| 2744 } |
| 2745 |
| 2746 |
| 2747 void FunctionType::WriteTo(Writer* writer) { |
| 2748 TRACE_WRITE_OFFSET(); |
| 2749 |
| 2750 bool is_simple = |
| 2751 positional_parameters_.length() == required_parameter_count_ && |
| 2752 type_parameters_.length() == 0 && named_parameters_.length() == 0; |
| 2753 if (is_simple) { |
| 2754 writer->WriteTag(kSimpleFunctionType); |
| 2755 positional_parameters_.WriteTo(writer); |
| 2756 return_type_->WriteTo(writer); |
| 2757 } else { |
| 2758 TypeParameterScope<WriterHelper> scope(writer->helper()); |
| 2759 writer->WriteTag(kFunctionType); |
| 2760 type_parameters_.WriteTo(writer); |
| 2761 writer->WriteUInt(required_parameter_count_); |
| 2762 positional_parameters_.WriteTo(writer); |
| 2763 named_parameters_.WriteTo(writer); |
| 2764 return_type_->WriteTo(writer); |
| 2765 } |
| 2766 } |
| 2767 |
| 2768 |
| 2769 TypeParameterType* TypeParameterType::ReadFrom(Reader* reader) { |
| 2770 TRACE_READ_OFFSET(); |
| 2771 TypeParameterType* type = new TypeParameterType(); |
| 2772 type->parameter_ = |
| 2773 reader->helper()->type_parameters().Lookup(reader->ReadUInt()); |
| 2774 return type; |
| 2775 } |
| 2776 |
| 2777 |
| 2778 void TypeParameterType::WriteTo(Writer* writer) { |
| 2779 TRACE_WRITE_OFFSET(); |
| 2780 writer->WriteTag(kTypeParameterType); |
| 2781 writer->WriteUInt(writer->helper()->type_parameters().Lookup(parameter_)); |
| 2782 } |
| 2783 |
| 2784 |
| 2785 Program* Program::ReadFrom(Reader* reader) { |
| 2786 TRACE_READ_OFFSET(); |
| 2787 uint32_t magic = reader->ReadUInt32(); |
| 2788 if (magic != kMagicProgramFile) FATAL("Invalid magic identifier"); |
| 2789 |
| 2790 Program* program = new Program(); |
| 2791 reader->helper()->set_program(program); |
| 2792 |
| 2793 program->string_table_.ReadFrom(reader); |
| 2794 StringTable dummy1; |
| 2795 dummy1.ReadFrom(reader); |
| 2796 LineStartingTable dummy2; |
| 2797 dummy2.ReadFrom(reader, dummy1.strings_.length()); |
| 2798 |
| 2799 int libraries = reader->ReadUInt(); |
| 2800 program->libraries().EnsureInitialized(libraries); |
| 2801 for (int i = 0; i < libraries; i++) { |
| 2802 program->libraries().GetOrCreate<Library>(i)->ReadFrom(reader); |
| 2803 } |
| 2804 |
| 2805 program->main_method_ = Procedure::Cast(Reference::ReadMemberFrom(reader)); |
| 2806 |
| 2807 return program; |
| 2808 } |
| 2809 |
| 2810 |
| 2811 void Program::WriteTo(Writer* writer) { |
| 2812 TRACE_WRITE_OFFSET(); |
| 2813 |
| 2814 writer->helper()->SetProgram(this); |
| 2815 |
| 2816 writer->WriteUInt32(kMagicProgramFile); |
| 2817 |
| 2818 // NOTE: Currently we don't GC strings and we require that all referenced |
| 2819 // strings in nodes are present in [string_table_]. |
| 2820 string_table_.WriteTo(writer); |
| 2821 StringTable dummy1; |
| 2822 dummy1.WriteTo(writer); |
| 2823 LineStartingTable dummy2; |
| 2824 dummy2.WriteTo(writer); |
| 2825 |
| 2826 libraries_.WriteTo(writer); |
| 2827 Reference::WriteMemberTo(writer, main_method_); |
| 2828 } |
| 2829 |
| 2830 |
| 2831 FunctionNode* FunctionNode::ReadFrom(Reader* reader) { |
| 2832 TRACE_READ_OFFSET(); |
| 2833 TypeParameterScope<ReaderHelper> scope(reader->helper()); |
| 2834 |
| 2835 FunctionNode* function = new FunctionNode(); |
| 2836 function->async_marker_ = |
| 2837 static_cast<FunctionNode::AsyncMarker>(reader->ReadByte()); |
| 2838 function->type_parameters().ReadFrom(reader); |
| 2839 function->required_parameter_count_ = reader->ReadUInt(); |
| 2840 function->positional_parameters().ReadFromStatic<VariableDeclarationImpl>( |
| 2841 reader); |
| 2842 function->named_parameters().ReadFromStatic<VariableDeclarationImpl>(reader); |
| 2843 function->return_type_ = DartType::ReadFrom(reader); |
| 2844 function->inferred_return_value_ = reader->ReadOptional<InferredValue>(); |
| 2845 |
| 2846 VariableScope<ReaderHelper> vars(reader->helper()); |
| 2847 function->body_ = reader->ReadOptional<Statement>(); |
| 2848 return function; |
| 2849 } |
| 2850 |
| 2851 |
| 2852 void FunctionNode::WriteTo(Writer* writer) { |
| 2853 TRACE_WRITE_OFFSET(); |
| 2854 TypeParameterScope<WriterHelper> scope(writer->helper()); |
| 2855 |
| 2856 writer->WriteByte(static_cast<uint8_t>(async_marker_)); |
| 2857 type_parameters().WriteTo(writer); |
| 2858 writer->WriteUInt(required_parameter_count()); |
| 2859 positional_parameters().WriteToStatic<VariableDeclarationImpl>(writer); |
| 2860 named_parameters().WriteToStatic<VariableDeclarationImpl>(writer); |
| 2861 return_type_->WriteTo(writer); |
| 2862 writer->WriteOptional<InferredValue>(inferred_return_value_); |
| 2863 |
| 2864 VariableScope<WriterHelper> vars(writer->helper()); |
| 2865 writer->WriteOptional<Statement>(body_); |
| 2866 } |
| 2867 |
| 2868 |
| 2869 TypeParameter* TypeParameter::ReadFrom(Reader* reader) { |
| 2870 TRACE_READ_OFFSET(); |
| 2871 name_ = Reference::ReadStringFrom(reader); |
| 2872 bound_ = DartType::ReadFrom(reader); |
| 2873 return this; |
| 2874 } |
| 2875 |
| 2876 |
| 2877 void TypeParameter::WriteTo(Writer* writer) { |
| 2878 TRACE_WRITE_OFFSET(); |
| 2879 name_->WriteTo(writer); |
| 2880 bound_->WriteTo(writer); |
| 2881 } |
| 2882 |
| 2883 |
| 2884 } // namespace kernel |
| 2885 |
| 2886 |
| 2887 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer, |
| 2888 intptr_t buffer_length) { |
| 2889 kernel::Reader reader(buffer, buffer_length); |
| 2890 return kernel::Program::ReadFrom(&reader); |
| 2891 } |
| 2892 |
| 2893 |
| 2894 void WritePrecompiledKernel(ByteWriter* byte_writer, kernel::Program* program) { |
| 2895 ASSERT(byte_writer != NULL); |
| 2896 |
| 2897 kernel::Writer writer(byte_writer); |
| 2898 program->WriteTo(&writer); |
| 2899 } |
| 2900 |
| 2901 |
| 2902 } // namespace dart |
OLD | NEW |