view release on metacpan or  search on metacpan

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

    }
  }

  bool wasReplaying = m_replaying;
  m_replaying = true;

  int macroIndex = 0;
  int childIndex = 0;
  while (macroIndex < block->macros.count() || childIndex < block->childBlocks.count()) {
    MacroBlock* child = childIndex < block->childBlocks.count() ? block->childBlocks.at(childIndex) : 0;
    pp_macro* macro = macroIndex < block->macros.count() ? block->macros.at(macroIndex) : 0;

    Q_ASSERT(child || macro);

    bool visitMacro = macro && (!child || (child->sourceLine < macro->sourceLine));

    if (!visitMacro) {
      Q_ASSERT(child);
      visitBlock(child, depth);
      ++childIndex;

    } else {
      Q_ASSERT(macro);
      if (macro->defined)
        setMacro(macro);
      else
        clearMacro(macro->name);
      ++macroIndex;
    }
  }

  // No need to visit else block, it will be skipped (already a matched block)

  m_replaying = wasReplaying;
}

MacroBlock* Environment::enterBlock(int sourceLine, const QVector<uint>& condition)
{
  MacroBlock* ret = new MacroBlock(sourceLine);
  ret->condition = condition;

  enterBlock(ret);

  return ret;
}

MacroBlock* Environment::elseBlock(int sourceLine, const QVector<uint>& condition)
{
  MacroBlock* ret = new MacroBlock(sourceLine);
  ret->condition = condition;

  Q_ASSERT(!m_blocks.isEmpty());
  m_blocks.top()->elseBlock = ret;

  m_blocks.pop();
  m_blocks.push(ret);

  return ret;
}

void Environment::swapMacros( Environment* parentEnvironment ) {
  EnvironmentMap oldEnvironment = m_environment;
  m_environment = parentEnvironment->m_environment;
  parentEnvironment->m_environment = oldEnvironment;
  
  if(!parentEnvironment->currentBlock()) {
    
    if(currentBlock()) {
      foreach(pp_macro* macro, m_environment)
        currentBlock()->macros.append(macro);
    }
  }else{
    //If both sides have a macro-block, it should be the same one, else the macros can not be safely swapped
    Q_ASSERT(parentEnvironment->firstBlock() == firstBlock());
  }
}

void Environment::leaveBlock()
{
  m_blocks.pop();
}

void Environment::clear()
{
  m_environment.clear();
  m_blocks.clear();
}

void Environment::clearMacro(const IndexedString& name)
{
//   pp_macro* undef = new pp_macro();
//   undef->name = name;
//   undef->defined = false;
//   if(!m_replaying)
//     m_blocks.top()->macros.append(undef);
// 
//   setMacro(undef); //Before, m_environment.remove(..) was called

 if(!m_replaying) {
    pp_macro* undef = new pp_macro;
    undef->name = name;
    undef->defined = false;
    m_blocks.top()->macros.append(undef);
  }

  ///@todo Think about how this plays together with environment-management
  ///We need undef-macros to be put into the definedMacros etc. lists
  m_environment.remove(name);
}

void Environment::setMacro(pp_macro* macro)
{
  if (!m_replaying && !m_blocks.isEmpty())
    m_blocks.top()->macros.append(macro);

/*  if( !macro->defined )
    clearMacro(macro->name);
  else*/
    m_environment.insert(macro->name, macro);
}

const Environment::EnvironmentMap& Environment::environment() const {
  return m_environment;
}

pp_macro* Environment::retrieveStoredMacro(const IndexedString& name) const
{
  EnvironmentMap::const_iterator it = m_environment.find(name);
  if (it != m_environment.end())
    return *it;

  return 0;
}