Make the parser agnostic to the TokenStream implementation. This is the first step towards compacti…

vm/flow_graph_compiler_ia32.h

 // Copyright (c) 2012, 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 VM_FLOW_GRAPH_COMPILER_IA32_H_
 #define VM_FLOW_GRAPH_COMPILER_IA32_H_
 
 #ifndef VM_FLOW_GRAPH_COMPILER_H_
 #error Include flow_graph_compiler.h instead of flow_graph_compiler_ia32.h.
 #endif
@@ skipping 58 matching lines @@
   void LoadDoubleOrSmiToXmm(XmmRegister result,
                             Register reg,
                             Register temp,
                             Label* not_double_or_smi);
 
   // Returns 'true' if code generation for this function is complete, i.e.,
   // no fall-through to regular code is needed.
   bool TryIntrinsify();
 
   void GenerateCallRuntime(intptr_t cid,
-                           intptr_t token_index,
+                           intptr_t token_pos,
                            intptr_t try_index,
                            const RuntimeEntry& entry);
 
   // Returns pc-offset (in bytes) of the pc after the call, can be used to emit
   // pc-descriptor information.
   intptr_t EmitStaticCall(const Function& function,
                           const Array& arguments_descriptor,
                           intptr_t argument_count);
 
-  void GenerateCall(intptr_t token_index,
+  void GenerateCall(intptr_t token_pos,
                     intptr_t try_index,
                     const ExternalLabel* label,
                     PcDescriptors::Kind kind);
   void GenerateInstanceOf(intptr_t cid,
-                          intptr_t token_index,
+                          intptr_t token_pos,
                           intptr_t try_index,
                           const AbstractType& type,
                           bool negate_result);
   void GenerateAssertAssignable(intptr_t cid,
-                                intptr_t token_index,
+                                intptr_t token_pos,
                                 intptr_t try_index,
                                 const AbstractType& dst_type,
                                 const String& dst_name);
 
   void GenerateInstanceCall(intptr_t cid,
-                            intptr_t token_index,
+                            intptr_t token_pos,
                             intptr_t try_index,
                             const String& function_name,
                             intptr_t argument_count,
                             const Array& argument_names,
                             intptr_t checked_argument_count);
 
   void GenerateStaticCall(intptr_t cid,
-                          intptr_t token_index,
+                          intptr_t token_pos,
                           intptr_t try_index,
                           const Function& function,
                           intptr_t argument_count,
                           const Array& argument_names);
 
   void GenerateInlinedMathSqrt(Label* done);
 
   void GenerateNumberTypeCheck(Register kClassIdReg,
                                const AbstractType& type,
                                Label* is_instance_lbl,
@@ skipping 34 matching lines @@
   // Returns assembler label associated with the given block entry.
   Label* GetBlockLabel(BlockEntryInstr* block_entry) const;
 
   // Returns true if the next block after current in the current block order
   // is the given block.
   bool IsNextBlock(TargetEntryInstr* block_entry) const;
 
   void AddExceptionHandler(intptr_t try_index, intptr_t pc_offset);
   void AddCurrentDescriptor(PcDescriptors::Kind kind,
                             intptr_t cid,
-                            intptr_t token_index,
+                            intptr_t token_pos,
                             intptr_t try_index);
   Label* AddDeoptStub(intptr_t deopt_id,
-                      intptr_t deopt_token_index,
+                      intptr_t deopt_token_pos,
                       intptr_t try_index_,
                       DeoptReasonId reason,
                       Register reg1 = kNoRegister,
                       Register reg2 = kNoRegister,
                       Register reg3 = kNoRegister);
 
   void FinalizeExceptionHandlers(const Code& code);
   void FinalizePcDescriptors(const Code& code);
   void FinalizeStackmaps(const Code& code);
   void FinalizeVarDescriptors(const Code& code);
@@ skipping 14 matching lines @@
 
   void GenerateDeferredCode();
 
   void CopyParameters();
   void EmitInstructionPrologue(Instruction* instr);
 
   void GenerateInlinedGetter(intptr_t offset);
   void GenerateInlinedSetter(intptr_t offset);
 
   RawSubtypeTestCache* GenerateInlineInstanceof(intptr_t cid,
-                                                intptr_t token_index,
+                                                intptr_t token_pos,
                                                 const AbstractType& type,
                                                 Label* is_instance_lbl,
                                                 Label* is_not_instance_lbl);
 
   RawSubtypeTestCache* GenerateInstantiatedTypeWithArgumentsTest(
       intptr_t cid,
-      intptr_t token_index,
+      intptr_t token_pos,
       const AbstractType& dst_type,
       Label* is_instance_lbl,
       Label* is_not_instance_lbl);
 
   void GenerateInstantiatedTypeNoArgumentsTest(intptr_t cid,
-                                               intptr_t token_index,
+                                               intptr_t token_pos,
                                                const AbstractType& dst_type,
                                                Label* is_instance_lbl,
                                                Label* is_not_instance_lbl);
 
   RawSubtypeTestCache* GenerateUninstantiatedTypeTest(
       intptr_t cid,
-      intptr_t token_index,
+      intptr_t token_pos,
       const AbstractType& dst_type,
       Label* is_instance_lbl,
       Label* is_not_instance_label);
 
   RawSubtypeTestCache* GenerateSubtype1TestCacheLookup(
       intptr_t cid,
-      intptr_t token_index,
+      intptr_t token_pos,
       const Class& type_class,
       Label* is_instance_lbl,
       Label* is_not_instance_lbl);
 
   enum TypeTestStubKind {
     kTestTypeOneArg,
     kTestTypeTwoArgs,
     kTestTypeThreeArgs,
   };
 
@@ skipping 40 matching lines @@
 
   FrameRegisterAllocator frame_register_allocator_;
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphCompiler);
 };
 
 
 class DeoptimizationStub : public ZoneAllocated {
  public:
   DeoptimizationStub(intptr_t deopt_id,
-                     intptr_t deopt_token_index,
+                     intptr_t deopt_token_pos,
                      intptr_t try_index,
                      DeoptReasonId reason)
       : deopt_id_(deopt_id),
-        deopt_token_index_(deopt_token_index),
+        deopt_token_pos_(deopt_token_pos),
         try_index_(try_index),
         reason_(reason),
         registers_(2),
         entry_label_() {}
 
   void Push(Register reg) { registers_.Add(reg); }
   Label* entry_label() { return &entry_label_; }
 
   // Implementation is in architecture specific file.
   void GenerateCode(FlowGraphCompiler* compiler);
 
  private:
   const intptr_t deopt_id_;
-  const intptr_t deopt_token_index_;
+  const intptr_t deopt_token_pos_;
   const intptr_t try_index_;
   const DeoptReasonId reason_;
   GrowableArray<Register> registers_;
   Label entry_label_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptimizationStub);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_COMPILER_IA32_H_