[kernel] [partial] Streaming of kernel binary without AST nodes

runtime/vm/kernel_binary.h

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_KERNEL_BINARY_H_
 #define RUNTIME_VM_KERNEL_BINARY_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include <map>
@@ skipping 250 matching lines @@
   explicit TypeParameterScope(T* builder) : builder_(builder) {
     builder_->type_parameters().EnterScope();
   }
   ~TypeParameterScope() { builder_->type_parameters().LeaveScope(); }
 
  private:
   T* builder_;
 };
 
 
-template <typename T>
-class SwitchCaseScope {
- public:
-  explicit SwitchCaseScope(T* builder) : builder_(builder) {
-    builder_->switch_cases().EnterScope();
-  }
-  ~SwitchCaseScope() { builder_->switch_cases().LeaveScope(); }
-
- private:
-  T* builder_;
-};
-
-
 // Unlike other scopes, labels from enclosing functions are not visible in
 // nested functions.  The LabelScope class is used to hide outer labels.
 template <typename Builder, typename Block>
 class LabelScope {
  public:
   explicit LabelScope(Builder* builder) : builder_(builder) {
     outer_block_ = builder_->labels();
     builder_->set_labels(&block_);
   }
   ~LabelScope() { builder_->set_labels(outer_block_); }
 
  private:
   Builder* builder_;
   Block block_;
   Block* outer_block_;
 };
 
 
 class ReaderHelper {
  public:
   ReaderHelper() : program_(NULL), labels_(NULL) {}
 
   Program* program() { return program_; }
   void set_program(Program* program) { program_ = program; }
 
   BlockStack<VariableDeclaration>& variables() { return scope_; }
   BlockStack<TypeParameter>& type_parameters() { return type_parameters_; }
-  BlockStack<SwitchCase>& switch_cases() { return switch_cases_; }
 
   BlockStack<LabeledStatement>* labels() { return labels_; }
   void set_labels(BlockStack<LabeledStatement>* labels) { labels_ = labels; }
 
  private:
   Program* program_;
   BlockStack<VariableDeclaration> scope_;
   BlockStack<TypeParameter> type_parameters_;
-  BlockStack<SwitchCase> switch_cases_;
   BlockStack<LabeledStatement>* labels_;
 };
 
 
 class Reader {
  public:
   Reader(const uint8_t* buffer, intptr_t size)
       : buffer_(buffer),
         size_(size),
         offset_(0),
@@ skipping 84 matching lines @@
     if (record) {
       record_token_position(result);
     }
     return result;
   }
 
   intptr_t ReadListLength() { return ReadUInt(); }
 
   uint8_t ReadByte() { return buffer_[offset_++]; }
 
+  uint8_t PeekByte() { return buffer_[offset_]; }
+
   bool ReadBool() { return (ReadByte() & 1) == 1; }
 
   word ReadFlags() { return ReadByte(); }
 
   Tag ReadTag(uint8_t* payload = NULL) {
     uint8_t byte = ReadByte();
     bool has_payload = (byte & kSpecializedTagHighBit) != 0;
     if (has_payload) {
       if (payload != NULL) {
         *payload = byte & kSpecializedPayloadMask;
       }
       return static_cast<Tag>(byte & kSpecializedTagMask);
     } else {
       return static_cast<Tag>(byte);
     }
   }
 
+  Tag PeekTag(uint8_t* payload = NULL) {
+    uint8_t byte = PeekByte();
+    bool has_payload = (byte & kSpecializedTagHighBit) != 0;
+    if (has_payload) {
+      if (payload != NULL) {
+        *payload = byte & kSpecializedPayloadMask;
+      }
+      return static_cast<Tag>(byte & kSpecializedTagMask);
+    } else {
+      return static_cast<Tag>(byte);
+    }
+  }
+
   const uint8_t* Consume(int count) {
     ASSERT(offset_ + count <= size_);
     const uint8_t* old = buffer_ + offset_;
     offset_ += count;
     return old;
   }
 
   void EnsureEnd() {
     if (offset_ != size_) {
       FATAL2(
@@ skipping 129 matching lines @@
   Reader* reader_;
   TokenPosition min_;
   TokenPosition max_;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_BINARY_H_