text: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline Token::Token( const Line& line ) : m_line(line)
  {
  	m_flags = 0;
  	m_broadcast = 0;
  	m_fields = 0;
  	m_operand = NULL;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline Token::Token( const Token& o ) : m_line(o.m_line)
  {
  	m_label = o.m_label;
  	m_name = o.m_name;
  	m_arguments = o.m_arguments;
  	m_flags = o.m_flags;
  	m_broadcast = o.m_broadcast;
  	m_fields = o.m_fields;
  	m_operand = o.m_operand;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::reset()
  {
  	m_label.clear();
  	m_name.clear();
  	m_arguments.clear();
  	m_flags = 0;
  	m_operand = NULL;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline const std::string& Token::label() const
  {
  	return m_label;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline const std::string& Token::name() const
  {
  	return m_name;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline std::list<Token::Argument>& Token::arguments()
  {
  	return m_arguments;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline const std::list<Token::Argument>& Token::arguments() const
  {
  	return m_arguments;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline unsigned int Token::flags() const
  {
  	return m_flags;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::setLabel( const std::string& label )
  {
  	m_label = label;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::setName( const std::string& opName )
  {
  	m_name = opName;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::addArgument( const std::string& arg )
  {
  	m_arguments.push_back(arg);
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::setFlags( unsigned int newFlags )
  {
  	m_flags = newFlags;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::setOperand( const Operand* o )
  {
  	m_operand = o;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline const Operand* Token::operand() const
  {
  	return m_operand;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline const Line& Token::line() const
  {
  	return m_line;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline Token::Argument::Argument( const std::string& text )
  {
  	m_text = text;
  
  	m_type = INVALID_TYPE;
  	m_content = INVALID_CONTENT;
  
  	m_regNumber = 0;
  
  	m_flags = 0;
  	m_fields = 0;
  
  	m_dependency = NULL;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline Token::Argument::Argument( const Argument& a )
  {
  	m_text = a.m_text;
  
  	m_type = a.m_type;
  	m_content = a.m_content;
  
  	m_regNumber = a.m_regNumber;
  	m_alias = a.m_alias;
  	m_immediate = a.m_immediate;
  
  	m_flags = a.m_flags;
  	m_fields = a.m_fields;
  
  	m_dependency = a.m_dependency;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::Argument::resetResult()
  {
  	m_type = INVALID_TYPE;
  	m_content = INVALID_CONTENT;
  	m_regNumber = 0;
  	m_flags = 0;
  	m_fields = 0;
  	m_alias.clear();
  	m_immediate.clear();
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline const std::string& Token::Argument::text() const
  {
  	return m_text;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::setFields( unsigned int fields )
  {
  	m_fields = fields;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline unsigned int Token::fields() const
  {
  	return m_fields;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::setBroadcast( unsigned int flag )
  {
  	m_broadcast = flag;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline unsigned int Token::broadcast() const
  {
  	return m_broadcast;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::Argument::setType( Type type )
  {
  	m_type = type;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline Token::Argument::Type Token::Argument::type() const
  {
  	return m_type;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline Token::Argument::Content Token::Argument::content() const
  {
  	return m_content;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::Argument::setRegNumber( int regNumber )
  {
  	m_content = REGISTER;
  	m_regNumber = regNumber;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline int Token::Argument::regNumber() const
  {
  	return m_regNumber;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::Argument::setAlias( const std::string& alias )
  {
  	m_content = ALIAS;
  	m_alias = alias;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline const std::string& Token::Argument::alias() const
  {
  	return m_alias;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::Argument::setImmediate( const std::string& immediate )
  {
  	m_immediate = immediate;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline const std::string& Token::Argument::immediate() const
  {
  	return m_immediate;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::Argument::setFlags( unsigned int flags )
  {
  	m_flags = flags;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline unsigned int Token::Argument::flags() const
  {
  	return m_flags;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::Argument::setFields( unsigned int fields )
  {
  	m_fields = fields;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline unsigned int Token::Argument::fields() const
  {
  	return m_fields;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline void Token::Argument::setDependency( Dependency* dependency )
  {
  	m_dependency = dependency;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline Dependency* Token::Argument::dependency() const
  {
  	return m_dependency;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  inline bool Token::hasModifier( Modifier modifier, unsigned int modifiers )
  {
  	return (modifiers & (1 << static_cast<int>(modifier))) != 0;
  }
  