Refactor Instruction classes to use a template base class.

vm/intermediate_language.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_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 292 matching lines @@
   DECLARE_COMPUTATION(ShortName)                                               \
   virtual void PrintTo(BufferFormatter* f) const;
 
 
 // Function defined in all call computation classes.
 #define DECLARE_CALL_COMPUTATION(ShortName)                                    \
   virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr);            \
   virtual ComputationType computation_type() const {                           \
     return Computation::k##ShortName;                                          \
   }                                                                            \
-  virtual intptr_t InputCount() const { return 0; }                            \
-  virtual Value* InputAt(intptr_t i) const {                                   \
-    UNREACHABLE();                                                             \
-    return NULL;                                                               \
-  }                                                                            \
-  virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }         \
   virtual const char* DebugName() const { return #ShortName; }                 \
   virtual RawAbstractType* StaticType() const;                                 \
   virtual LocationSummary* MakeLocationSummary() const;                        \
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
 
 class Definition;
 class PhiInstr;
 
 class UseVal : public Value {
@@ skipping 140 matching lines @@
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StoreContextComp);
 };
 
 
-class ClosureCallComp : public Computation {
+class ClosureCallComp : public TemplateComputation<0> {
  public:
   ClosureCallComp(ClosureCallNode* node,
                   intptr_t try_index,
                   ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : ast_node_(*node),
         try_index_(try_index),
         arguments_(arguments) { }
 
   DECLARE_CALL_COMPUTATION(ClosureCall)
 
@@ skipping 12 matching lines @@
 
  private:
   const ClosureCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallComp);
 };
 
 
-class InstanceCallComp : public Computation {
+class InstanceCallComp : public TemplateComputation<0> {
  public:
   InstanceCallComp(intptr_t token_pos,
                    intptr_t try_index,
                    const String& function_name,
                    Token::Kind token_kind,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments,
                    const Array& argument_names,
                    intptr_t checked_argument_count)
       : token_pos_(token_pos),
         try_index_(try_index),
@@ skipping 35 matching lines @@
   const String& function_name_;
   const Token::Kind token_kind_;  // Binary op, unary op, kGET or kILLEGAL.
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   const Array& argument_names_;
   const intptr_t checked_argument_count_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallComp);
 };
 
 
-class PolymorphicInstanceCallComp : public Computation {
+class PolymorphicInstanceCallComp : public TemplateComputation<0> {
  public:
   explicit PolymorphicInstanceCallComp(InstanceCallComp* comp)
       : instance_call_(comp) {
     ASSERT(instance_call_ != NULL);
   }
 
   InstanceCallComp* instance_call() const { return instance_call_; }
 
-  virtual intptr_t InputCount() const { return 0; }
-  virtual Value* InputAt(intptr_t i) const {
-    UNREACHABLE();
-    return NULL;
-  }
-  virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
-
   void PrintTo(BufferFormatter* f) const;
 
   DECLARE_COMPUTATION(PolymorphicInstanceCall)
 
   virtual bool CanDeoptimize() const { return true; }
 
  private:
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallComp);
@@ skipping 106 matching lines @@
 
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   intptr_t operands_class_id_;  // class id of both operands.
 
   DISALLOW_COPY_AND_ASSIGN(RelationalOpComp);
 };
 
 
-class StaticCallComp : public Computation {
+class StaticCallComp : public TemplateComputation<0> {
  public:
   StaticCallComp(intptr_t token_pos,
                  intptr_t try_index,
                  const Function& function,
                  const Array& argument_names,
                  ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : token_pos_(token_pos),
         try_index_(try_index),
         function_(function),
         argument_names_(argument_names),
@@ skipping 451 matching lines @@
   virtual bool CanDeoptimize() const { return false; }
 
  private:
   const ConstructorCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const arguments_;
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckComp);
 };
 
 
-class CreateArrayComp : public Computation {
+class CreateArrayComp : public TemplateComputation<1> {
  public:
   CreateArrayComp(intptr_t token_pos,
                   intptr_t try_index,
                   ZoneGrowableArray<Value*>* elements,
                   Value* element_type)
       : token_pos_(token_pos),
         try_index_(try_index),
         elements_(elements) {
 #if defined(DEBUG)
     for (int i = 0; i < ElementCount(); ++i) {
       ASSERT(ElementAt(i) != NULL);
     }
     ASSERT(element_type != NULL);
 #endif
+    inputs_[0] = element_type;
   }
 
   DECLARE_CALL_COMPUTATION(CreateArray)
 
-  virtual intptr_t ArgumentCount() const { return ElementCount() + 1; }
+  virtual intptr_t ArgumentCount() const { return ElementCount(); }
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   intptr_t ElementCount() const { return elements_->length(); }
   Value* ElementAt(intptr_t i) const { return (*elements_)[i]; }
-  Value* element_type() const { return element_type_; }
+  Value* element_type() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const elements_;
-  Value* element_type_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayComp);
 };
 
 
-class CreateClosureComp : public Computation {
+class CreateClosureComp : public TemplateComputation<0> {
  public:
   CreateClosureComp(ClosureNode* node,
                     intptr_t try_index,
                     ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : ast_node_(*node),
         try_index_(try_index),
         arguments_(arguments) { }
 
   DECLARE_CALL_COMPUTATION(CreateClosure)
 
@@ skipping 320 matching lines @@
 
  private:
   const Token::Kind op_kind_;
   const OperandsType operands_type_;
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryOpComp);
 };
 
 
-class DoubleBinaryOpComp : public Computation {
+class DoubleBinaryOpComp : public TemplateComputation<0> {
  public:
   DoubleBinaryOpComp(Token::Kind op_kind, InstanceCallComp* instance_call)
       : op_kind_(op_kind), instance_call_(instance_call) { }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   InstanceCallComp* instance_call() const { return instance_call_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
@@ skipping 164 matching lines @@
 #define FORWARD_DECLARATION(type) class type##Instr;
 FOR_EACH_INSTRUCTION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 
 // Functions required in all concrete instruction classes.
 #define DECLARE_INSTRUCTION(type)                                              \
   virtual void Accept(FlowGraphVisitor* visitor);                              \
   virtual bool Is##type() const { return true; }                               \
   virtual type##Instr* As##type() { return this; }                             \
-  virtual intptr_t InputCount() const;                                         \
-  virtual Value* InputAt(intptr_t i) const;                                    \
-  virtual void SetInputAt(intptr_t i, Value* value);                           \
-  virtual const char* DebugName() const { return #type; }                      \
-  virtual void PrintTo(BufferFormatter* f) const;                              \
-  virtual void PrintToVisualizer(BufferFormatter* f) const;
-
-
-#define DECLARE_CALL_INSTRUCTION(type)                                         \
-  virtual void Accept(FlowGraphVisitor* visitor);                              \
-  virtual bool Is##type() const { return true; }                               \
-  virtual type##Instr* As##type() { return this; }                             \
-  virtual intptr_t InputCount() const { return 0; }                            \
-  virtual Value* InputAt(intptr_t i) const {                                   \
-    UNREACHABLE();                                                             \
-    return NULL;                                                               \
-  }                                                                            \
-  virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }         \
   virtual const char* DebugName() const { return #type; }                      \
   virtual void PrintTo(BufferFormatter* f) const;                              \
   virtual void PrintToVisualizer(BufferFormatter* f) const;
 
 
 class Instruction : public ZoneAllocated {
  public:
   Instruction()
       : lifetime_position_(-1), previous_(NULL), next_(NULL), env_(NULL) { }
 
@@ skipping 112 matching lines @@
 
  private:
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
-class InstructionWithInputs : public Instruction {
+template<intptr_t N>
+class TemplateInstruction: public Instruction {
  public:
-  InstructionWithInputs() : locs_(NULL) { }
+  TemplateInstruction<N>() : locs_(NULL) { }
+
+  virtual intptr_t InputCount() const { return N; }
+  virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
+  virtual void SetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 
   virtual LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
   virtual LocationSummary* MakeLocationSummary() const = 0;
 
+ protected:
+  EmbeddedArray<Value*, N> inputs_;
+
  private:
   LocationSummary* locs_;
-  DISALLOW_COPY_AND_ASSIGN(InstructionWithInputs);
 };
 
 
 class MoveOperands : public ZoneAllocated {
  public:
   MoveOperands(Location dest, Location src) : dest_(dest), src_(src) { }
 
   Location src() const { return src_; }
   Location dest() const { return dest_; }
 
@@ skipping 41 matching lines @@
   }
 
  private:
   Location dest_;
   Location src_;
 
   DISALLOW_COPY_AND_ASSIGN(MoveOperands);
 };
 
 
-class ParallelMoveInstr : public Instruction {
+class ParallelMoveInstr : public TemplateInstruction<0> {
  public:
   ParallelMoveInstr() : moves_(4) { }
 
   DECLARE_INSTRUCTION(ParallelMove)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   MoveOperands* AddMove(Location dest, Location src) {
     MoveOperands* move = new MoveOperands(dest, src);
     moves_.Add(move);
     return move;
   }
 
   MoveOperands* MoveOperandsAt(intptr_t index) const { return moves_[index]; }
 
   void SetSrcSlotAt(intptr_t index, const Location& loc);
   void SetDestSlotAt(intptr_t index, const Location& loc);
 
   intptr_t NumMoves() const { return moves_.length(); }
 
+  LocationSummary* MakeLocationSummary() const { return NULL; }
+
+  void EmitNativeCode(FlowGraphCompiler* compiler) { UNREACHABLE(); }
+
  private:
   GrowableArray<MoveOperands*> moves_;   // Elements cannot be null.
 
   DISALLOW_COPY_AND_ASSIGN(ParallelMoveInstr);
 };
 
 
 // Basic block entries are administrative nodes.  There is a distinguished
 // graph entry with no predecessor.  Joins are the only nodes with multiple
 // predecessors.  Targets are all other basic block entries.  The types
@@ skipping 53 matching lines @@
 
   virtual void DiscoverBlocks(
       BlockEntryInstr* current_block,
       GrowableArray<BlockEntryInstr*>* preorder,
       GrowableArray<BlockEntryInstr*>* postorder,
       GrowableArray<intptr_t>* parent,
       GrowableArray<BitVector*>* assigned_vars,
       intptr_t variable_count,
       intptr_t fixed_parameter_count);
 
+  virtual intptr_t InputCount() const { return 0; }
+  virtual Value* InputAt(intptr_t i) const {
+    UNREACHABLE();
+    return NULL;
+  }
+  virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
+
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return false; }
 
  protected:
   BlockEntryInstr()
       : preorder_number_(-1),
         postorder_number_(-1),
         block_id_(-1),
         dominator_(NULL),
@@ skipping 250 matching lines @@
   BindInstr(UseKind used, Computation* computation)
       : computation_(computation), is_used_(used != kUnused) {
     ASSERT(computation != NULL);
   }
 
   DECLARE_INSTRUCTION(Bind)
 
   virtual intptr_t ArgumentCount() const {
     return computation()->ArgumentCount();
   }
+  intptr_t InputCount() const { return computation()->InputCount(); }
+
+  Value* InputAt(intptr_t i) const { return computation()->InputAt(i); }
+
+  void SetInputAt(intptr_t i, Value* value) {
+    computation()->SetInputAt(i, value);
+  }
 
   virtual bool CanDeoptimize() const { return computation()->CanDeoptimize(); }
 
   Computation* computation() const { return computation_; }
   void set_computation(Computation* value) { computation_ = value; }
   bool is_used() const { return is_used_; }
 
   // Static type of the underlying computation.
   virtual RawAbstractType* StaticType() const {
     return computation()->StaticType();
@@ skipping 22 matching lines @@
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
     }
   }
 
   // Least upper bound of the static types of the inputs.
   virtual RawAbstractType* StaticType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
+  intptr_t InputCount() const { return inputs_.length(); }
+
+  Value* InputAt(intptr_t i) const { return inputs_[i]; }
+
+  void SetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
+
   virtual bool CanDeoptimize() const { return false; }
 
   DECLARE_INSTRUCTION(Phi)
 
  private:
   GrowableArray<Value*> inputs_;
 
   DISALLOW_COPY_AND_ASSIGN(PhiInstr);
 };
 
 
 class ParameterInstr : public Definition {
  public:
   explicit ParameterInstr(intptr_t index) : index_(index) { }
 
   DECLARE_INSTRUCTION(Parameter)
 
   intptr_t index() const { return index_; }
 
   // Static type of the passed-in parameter.
   virtual RawAbstractType* StaticType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
+  intptr_t InputCount() const { return 0; }
+  Value* InputAt(intptr_t i) const {
+    UNREACHABLE();
+    return NULL;
+  }
+  void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
+
+
   virtual bool CanDeoptimize() const { return false; }
 
  private:
   const intptr_t index_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
-class PushArgumentInstr : public InstructionWithInputs {
+class PushArgumentInstr : public TemplateInstruction<1> {
  public:
-  explicit PushArgumentInstr(Value* value) : value_(value) { }
+  explicit PushArgumentInstr(Value* value) {
+    ASSERT(value != NULL);
+    inputs_[0] = value;
+  }
 
   DECLARE_INSTRUCTION(PushArgument)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
-  Value* value() const { return value_; }
+  Value* value() const { return inputs_[0]; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
-  Value* value_;
-
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
-class ReturnInstr : public InstructionWithInputs {
+class ReturnInstr : public TemplateInstruction<1> {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
-      : InstructionWithInputs(),
-        cid_(Isolate::Current()->GetNextCid()),
-        token_pos_(token_pos),
-        value_(value) {
-    ASSERT(value_ != NULL);
+      : cid_(Isolate::Current()->GetNextCid()),
+        token_pos_(token_pos) {
+    ASSERT(value != NULL);
+    inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(Return)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t cid() const { return cid_; }
   intptr_t token_pos() const { return token_pos_; }
-  Value* value() const { return value_; }
+  Value* value() const { return inputs_[0]; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
   const intptr_t cid_;  // Computation/instruction id.
   const intptr_t token_pos_;
-  Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
-class ThrowInstr : public InstructionWithInputs {
+class ThrowInstr : public TemplateInstruction<0> {
  public:
   ThrowInstr(intptr_t token_pos, intptr_t try_index)
-      : InstructionWithInputs(),
-        cid_(Isolate::Current()->GetNextCid()),
+      : cid_(Isolate::Current()->GetNextCid()),
         token_pos_(token_pos),
         try_index_(try_index) { }
 
-  DECLARE_CALL_INSTRUCTION(Throw)
+  DECLARE_INSTRUCTION(Throw)
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   intptr_t cid() const { return cid_; }
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
   const intptr_t cid_;  // Computation/instruction id.
   const intptr_t token_pos_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
-class ReThrowInstr : public InstructionWithInputs {
+class ReThrowInstr : public TemplateInstruction<0> {
  public:
   ReThrowInstr(intptr_t token_pos,
                intptr_t try_index)
-      : InstructionWithInputs(),
-        cid_(Isolate::Current()->GetNextCid()),
+      : cid_(Isolate::Current()->GetNextCid()),
         token_pos_(token_pos),
         try_index_(try_index) { }
 
-  DECLARE_CALL_INSTRUCTION(ReThrow)
+  DECLARE_INSTRUCTION(ReThrow)
 
   virtual intptr_t ArgumentCount() const { return 2; }
 
   intptr_t cid() const { return cid_; }
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
   const intptr_t cid_;  // Computation/instruction id.
   const intptr_t token_pos_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
-class GotoInstr : public InstructionWithInputs {
+class GotoInstr : public TemplateInstruction<0> {
  public:
   explicit GotoInstr(JoinEntryInstr* entry)
     : successor_(entry),
-      parallel_move_(NULL) {
-  }
+      parallel_move_(NULL) { }
 
   DECLARE_INSTRUCTION(Goto)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   JoinEntryInstr* successor() const { return successor_; }
   void set_successor(JoinEntryInstr* successor) { successor_ = successor; }
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
@@ skipping 20 matching lines @@
 
  private:
   JoinEntryInstr* successor_;
 
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the end of the block and resolve phis.
   ParallelMoveInstr* parallel_move_;
 };
 
 
-class BranchInstr : public InstructionWithInputs {
+class BranchInstr : public TemplateInstruction<2> {
  public:
   BranchInstr(intptr_t token_pos,
               intptr_t try_index,
               Value* left,
               Value* right,
               Token::Kind kind)
-      : InstructionWithInputs(),
-        cid_(Computation::kNoCid),
+      : cid_(Computation::kNoCid),
         ic_data_(NULL),
         token_pos_(token_pos),
         try_index_(try_index),
-        left_(left),
-        right_(right),
         kind_(kind),
         true_successor_(NULL),
         false_successor_(NULL) {
-    ASSERT(left_ != NULL);
-    ASSERT(right_ != NULL);
+    ASSERT(left != NULL);
+    ASSERT(right != NULL);
+    inputs_[0] = left;
+    inputs_[1] = right;
     ASSERT(Token::IsEqualityOperator(kind) ||
            Token::IsRelationalOperator(kind) ||
            Token::IsTypeTestOperator(kind));
     Isolate* isolate = Isolate::Current();
     cid_ = isolate->GetNextCid();
     ic_data_ = isolate->GetICDataForCid(cid_);
   }
 
   DECLARE_INSTRUCTION(Branch)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
-  Value* left() const { return left_; }
-  Value* right() const { return right_; }
+  Value* left() const { return inputs_[0]; }
+  Value* right() const { return inputs_[1]; }
   Token::Kind kind() const { return kind_; }
   void set_kind(Token::Kind kind) {
     ASSERT(Token::IsEqualityOperator(kind) ||
            Token::IsRelationalOperator(kind) ||
            Token::IsTypeTestOperator(kind));
     kind_ = kind;
   }
 
   intptr_t cid() const { return cid_; }
 
@@ skipping 30 matching lines @@
   void EmitBranchOnCondition(FlowGraphCompiler* compiler,
                              Condition true_condition);
 
   virtual bool CanDeoptimize() const { return true; }
 
  private:
   intptr_t cid_;  // Computation/instruction id.
   ICData* ic_data_;
   const intptr_t token_pos_;
   const intptr_t try_index_;
-  Value* left_;
-  Value* right_;
   Token::Kind kind_;
   TargetEntryInstr* true_successor_;
   TargetEntryInstr* false_successor_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
 #undef DECLARE_INSTRUCTION
 
@@ skipping 73 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_