view release on metacpan or  search on metacpan

generator/parser/rpp/pp-stream.cpp  view on Meta::CPAN

    // TODO check correctness Probably remove
    m_inputLineStartedAt = m_pos - (string.size() - string.lastIndexOf(newline)); ///@todo remove
  }
  return *this;
}

Stream& Stream::appendString( const Anchor& inputPosition, IndexedString string )
{

  if (!isNull()) {
    
/*    if(m_pos > 0) {
      //Eventually merge
      unsigned int& previous( (*m_string)[m_pos-1] );
      if(shouldMergeTo(previous)) {
        if(shouldMerge(string.index())) {
          //We have to merge with the previous character, so we get a correct tokenization. This should not happen too often.
          previous = IndexedString(IndexedString(previous).byteArray() + string.byteArray()).index();
          kDebug() << "merging" << IndexedString(previous).str() << "and" << string.str();
          return *this; ///We lose the input-position, but on the other hand we would lose it anyway on another level
        }
      }
    }*/
    
    mark(inputPosition);
    m_string->append(string.index());

    int extraLines = 0;
    if (string.index() == newline) {
      m_pos += 1; //Move the current offset to that position, so the marker is set correctly
      if(!inputPosition.collapsed)
        mark(Anchor(inputPosition.line + ++extraLines, 0, false, m_macroExpansion));
      m_pos -= 1;
    }

    m_pos += 1;

    // TODO check correctness Probably remove
    m_inputLineStartedAt = m_pos; ///@todo remove
  }
  return *this;
}

bool Stream::isNull() const
{
  return m_isNull;
}

Anchor Stream::inputPosition() const
{
  return Anchor(m_inputLine, m_pos - m_inputLineStartedAt, m_inputPositionLocked, m_macroExpansion);
}

void Stream::setInputPosition(const Anchor& position)
{
  m_inputLine = position.line;
  m_inputLineStartedAt = m_pos - position.column;
  m_inputPositionLocked = position.collapsed;
}

void Stream::setMacroExpansion(const SimpleCursor& expansion)
{
  m_macroExpansion = expansion;
}

SimpleCursor Stream::macroExpansion() const
{
  return m_macroExpansion;
}

rpp::Anchor rpp::Stream::currentOutputAnchor() const {
  if(m_locationTable)
    return m_locationTable->positionAt(m_pos, *m_string).first;
  return rpp::Anchor();
}

void Stream::mark(const Anchor& position)
{
  Q_ASSERT(m_pos <= m_string->size());
  if (m_locationTable) {
    if(m_macroExpansion.isValid()) {
      Anchor a(position);
      a.macroExpansion = m_macroExpansion;
      m_locationTable->anchor(m_pos, a, m_string);
    }else{
      m_locationTable->anchor(m_pos, position, m_string);
    }
  }
}

void Stream::reset( )
{
  c = m_string->constData();
  m_inputLineStartedAt = m_inputLine = m_pos = 0;
  m_inputPositionLocked = false;
}

QByteArray rpp::Stream::stringFrom(int offset) const
{
  QByteArray ret;
  for(int a = offset; a < m_pos; ++a)
    ret += IndexedString::fromIndex((*m_string)[a]).byteArray();
  
  return ret;
}

SimpleCursor rpp::Stream::originalInputPosition() const
{
  if (m_originalInputPosition.isValid())
    return m_originalInputPosition;

  return inputPosition();
}

void rpp::Stream::setOriginalInputPosition(const SimpleCursor & position)
{
  m_originalInputPosition = position;
}