nxsreader.cpp

//  Copyright (C) 1999-2003 Paul O. Lewis
//
//  This file is part of NCL (Nexus Class Library) version 2.0.
//
//  NCL is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  NCL is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with NCL; if not, write to the Free Software Foundation, Inc.,
//  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
#include <csignal>
#include <algorithm>
#include <set>
#include <fstream>
#include <climits>
#include <sstream>
#include "ncl/nxsreader.h"
#include "ncl/nxsdefs.h"

#include "ncl/nxscharactersblock.h"
#include "ncl/nxstaxablock.h"
#include "ncl/nxstreesblock.h"

using namespace std;

#if defined(NCL_CONST_FUNCS) && NCL_CONST_FUNCS
    int onlyDefinedInCouldBeConst()
    {
        return 1;
    }

#endif


static void NxsHandleSignalCallback(int);

NxsReader::SignalHandlerFuncPtr NxsReader::prevSignalCatcher = 0L;
bool NxsReader::nclCatchesSignals = false;
unsigned NxsReader::numSigIntsCaught = 0;
bool NxsReader::prevSignalStored = true;

unsigned NxsReader::getNumSignalIntsCaught()
    {
    return NxsReader::numSigIntsCaught;
    }

void NxsReader::setNumSignalsIntsCaught(unsigned n)
    {
    NxsReader::numSigIntsCaught = n;
    }

void NxsReader::setNCLCatchesSignals(bool v)
    {
    NxsReader::nclCatchesSignals = v;
    }

bool NxsReader::getNCLCatchesSignals()
    {
    return NxsReader::nclCatchesSignals;
    }


void NxsHandleSignalCallback(int)
    {
    unsigned nc = NxsReader::getNumSignalIntsCaught();
    NxsReader::setNumSignalsIntsCaught(1 + nc);
    }

void NxsReader::installNCLSignalHandler()
    {
    NxsReader::SignalHandlerFuncPtr prev = std::signal(SIGINT, SIG_IGN);
    if (prev != SIG_IGN)
        {
        NxsReader::prevSignalCatcher = prev;
        NxsReader::prevSignalStored = true;
        std::signal(SIGINT, NxsHandleSignalCallback);
        }
    }

void NxsReader::uninstallNCLSignalHandler()
    {
    if (prevSignalStored)
        {
        std::signal(SIGINT, NxsReader::prevSignalCatcher);
        NxsReader::prevSignalCatcher = 0L;
        NxsReader::prevSignalStored = false;
        }
    }



void NxsReader::ReadFilepath(const char *filename)
    {
    std::ifstream inf;
    try{
        inf.open(filename, ios::binary);
        if (!inf.good())
            {
            NxsString err;
            err << "Could not open the file \"" << filename <<"\"";
            this->NexusError(err, 0, -1, -1);
            }
        }
    catch (...)
        {
        NxsString err;
        err << '\"' << filename <<"\" does not refer to a valid file." ;
        this->NexusError(err, 0, -1, -1);
        }
    this->ReadFilestream(inf);
    }


void NxsReader::ReadStringAsNexusContent(const std::string & s)
    {
    std::istringstream inf(s);
    this->ReadFilestream(inf);
    }

void NxsReader::ReadFilestream(std::istream & inf)
    {
    NxsToken token(inf);
    this->Execute(token);
    }

std::set<NxsBlock *> NxsReader::RemoveBlocksFromFactoriesFromUsedBlockLists()
    {
    std::set<NxsBlock *> todel;
    BlockReaderList saved;
    for (BlockReaderList::iterator bIt = blocksInOrder.begin(); bIt != blocksInOrder.end(); ++bIt)
        {
        NxsBlock * b  = *bIt;
        if (BlockIsASingeltonReader(b))
            saved.push_back(b);
        else
            {
            todel.insert(b);
            }
        }
    for (std::set<NxsBlock *>::iterator d = todel.begin(); d != todel.end(); ++d)
        {
        RemoveBlockFromUsedBlockList(*d);
        }
    return todel;
    }

void NxsReader::DeleteBlocksFromFactories()
    {
    std::set<NxsBlock *> todel = RemoveBlocksFromFactoriesFromUsedBlockLists();
    for (std::set<NxsBlock *>::iterator d = todel.begin(); d != todel.end(); ++d)
        delete *d;
    }

bool NxsReader::BlockIsASingeltonReader(NxsBlock *b) const
    {
    NxsBlock * sb = blockList;
    while (sb)
        {
        if (b == sb)
            return true;
        sb = sb->next;
        }
    return false;
    }

NxsBlock *NxsReader::FindBlockByTitle(const BlockReaderList & chosenBlockList, const char *title, unsigned *nMatches)
    {
    BlockReaderList  found = FindAllBlocksByTitle(chosenBlockList, title);

    if (found.empty())
        {
        if (nMatches)
            *nMatches = 0;
        return NULL;
        }
    if (nMatches)
        *nMatches = (unsigned)found.size();
    return (NxsBlock *) found.front();
    }



BlockReaderList NxsReader::FindAllBlocksByTitle(const BlockReaderList & chosenBlockList, const char *title)
    {
    BlockReaderList found = FindAllBlocksByTitleNoPrioritization(chosenBlockList, title);
    if (found.empty())
        return found;
    map<int, BlockReaderList> byPriority;
    for (BlockReaderList::const_iterator fIt = found.begin(); fIt != found.end(); ++fIt)
        {
        NxsBlock * b = *fIt;
        int priority = GetBlockPriority(b);
        byPriority[priority].push_back(b);
        }
    NCL_ASSERT(!byPriority.empty());
    return byPriority.rbegin()->second;
    }

BlockReaderList NxsReader::FindAllBlocksByTitleNoPrioritization(const BlockReaderList & chosenBlockList, const char *title)
    {
    BlockReaderList found;
    if (chosenBlockList.empty() || title == NULL)
        {
        found = chosenBlockList;
        }
    else
        {
        bool emptyTitle = strlen(title) == 0;
        for (BlockReaderList::const_iterator cblIt = chosenBlockList.begin(); cblIt != chosenBlockList.end(); ++cblIt)
            {
            NxsBlock * b = *cblIt;
            std::vector<std::string> v = this->GetAllTitlesForBlock(b);
            for (std::vector<std::string>::const_iterator vIt = v.begin(); vIt != v.end(); ++vIt)
                {
                const std::string & n = *vIt;
                if ((emptyTitle && n.empty()) || (NxsString::case_insensitive_equals(title, n.c_str())))
                    {
                    found.push_back(b);
                    break;
                    }
                }
            }
        }
    return found;

    }

std::vector<std::string> NxsReader::GetAllTitlesForBlock(const NxsBlock *b) const
    {
    std::vector<std::string> v;
    v.push_back(b->GetTitle());
    std::map<const NxsBlock *, std::list<std::string> >::const_iterator a = blockTitleAliases.find(b);
    if (a != blockTitleAliases.end())
        std::copy(a->second.begin(), a->second.end(), back_inserter(v));
    return v;
    }

void NxsReader::RegisterAltTitle(const NxsBlock * b, std::string t)
    {
    std::list<std::string> & v = blockTitleAliases[b];
    v.push_back(t);
    }

NxsBlock *NxsReader::FindBlockOfTypeByTitle(const std::string &btype, const char *title, unsigned *nMatches)
    {
    BlockTypeToBlockList::const_iterator btblIt = blockTypeToBlockList.find(btype);
    if (btblIt == blockTypeToBlockList.end())
        {
        if (nMatches)
            *nMatches = 0;
        return NULL;
        }
    const BlockReaderList & chosenBlockList = btblIt->second;
    return FindBlockByTitle(chosenBlockList, title, nMatches);
    }

NxsTaxaBlockAPI *NxsReader::GetTaxaBlockByTitle(const char *title, unsigned *nMatches)
    {
    const std::string btype("TAXA");
    return static_cast<NxsTaxaBlockAPI *>(FindBlockOfTypeByTitle(btype, title, nMatches));
    }

NxsCharactersBlockAPI   *NxsReader::GetCharBlockByTitle(const char *title, unsigned *nMatches)
    {
    const std::string btype("CHARACTERS");
    return static_cast<NxsCharactersBlockAPI *>(FindBlockOfTypeByTitle(btype, title, nMatches));
    }
NxsTreesBlockAPI *NxsReader::GetTreesBlockByTitle(const char *title, unsigned *nMatches)
    {
    const std::string btype("TREES");
    return static_cast<NxsTreesBlockAPI *>(FindBlockOfTypeByTitle(btype, title, nMatches));
    }

NxsReader::NxsReader() : currentWarningLevel(UNCOMMON_SYNTAX_WARNING), alwaysReportStatusMessages(false)
    {
    blockList   = NULL;
    currBlock   = NULL;
    taxaBlockFactory = NULL;
    destroyRepeatedTaxaBlocks = false;
    }

NxsReader::~NxsReader()
    {
    NxsBlock *curr;
    for (curr = blockList; curr;)
        {
        if (curr->GetNexus() == this)
            curr->SetNexus(NULL);
        curr = curr->next;
        }
    for (BlockReaderList::iterator b = blocksInOrder.begin(); b != blocksInOrder.end(); ++b)
        {
        if ((*b)->GetNexus() == this)
            (*b)->SetNexus(NULL);
        }

    }

void NxsReader::AddFactory(NxsBlockFactory *f)
    {
    if (f)
        factories.push_front(f);
    }
void NxsReader::RemoveFactory(NxsBlockFactory *f)
    {
    factories.remove(f);
    }


void NxsReader::Add(
  NxsBlock *newBlock)   /* a pointer to an existing block object */
    {
    NCL_ASSERT(newBlock != NULL);

    newBlock->SetNexus(this);

    if (!blockList)
        blockList = newBlock;
    else
        {
        // Add new block to end of list
        //
        NxsBlock *curr;
        for (curr = blockList; curr && curr->next;)
            curr = curr->next;
        NCL_ASSERT(curr && !curr->next);
        curr->next = newBlock;
        }
    }

unsigned NxsReader::PositionInBlockList(
  NxsBlock *b)  /* a pointer to an existing block object */
    {
    unsigned pos = 0;
    NxsBlock *curr = blockList;

    for (;;)
        {
        if (curr == NULL || curr == b)
            break;
        pos++;
        curr = curr->next;
        }

    if (curr == NULL)
        pos = UINT_MAX;

    return pos;
    }

void NxsReader::Reassign(
  NxsBlock *oldb,   /* a pointer to the block object soon to be deleted */
  NxsBlock *newb)   /* a pointer to oldb's replacement */
    {
    NxsBlock *prev = NULL;
    NxsBlock *curr = blockList;
    newb->SetNexus(this);

    for (;;)
        {
        if (curr == NULL || curr == oldb)
            break;
        prev = curr;
        curr = curr->next;
        }

    NCL_ASSERT(curr != NULL);

    newb->next = curr->next;
    if (prev == NULL)
        blockList = newb;
    else
        prev->next = newb;
    curr->next = NULL;
    curr->SetNexus(NULL);
    }

bool NxsReader::BlockListEmpty()
    {
    return (blockList == NULL ? true : false);
    }

void NxsReader::DebugReportBlock(
  NxsBlock &)   /* the block that should be reported */
    {
    }

void NxsReader::Detach(
  NxsBlock *oldBlock)   /* a pointer to an existing block object */
    {
    NCL_ASSERT(oldBlock != NULL);
    RemoveBlockFromUsedBlockList(oldBlock);
    // Return quietly if there are not blocks attached
    //
    if (blockList == NULL)
        return;

    if (blockList == oldBlock)
        {
        blockList = oldBlock->next;
        oldBlock->SetNexus(NULL);
        }
    else
        {
        // Bug fix MTH 6/17/2002: old version detached intervening blocks as well
        //
        NxsBlock *curr = blockList;
        for (; curr->next != NULL && curr->next != oldBlock;)
            curr = curr->next;

        // Line below can be uncommented to find cases where Detach function is
        // called for pointers that are not in the linked list. If line below is
        // uncommented, the part of the descriptive comment that precedes this
        // function about "...simply returns quietly" will be incorrect (at least
        // in the Debugging version of the program where asserts are active).
        //
        //NCL_ASSERT(curr->next == oldBlock);

        if (curr->next == oldBlock)
            {
            curr->next = oldBlock->next;
            oldBlock->SetNexus(NULL);
            }
        }
    }

bool NxsReader::EnteringBlock(
  NxsString )   /* the name of the block just entered */
    {
    return true;
    }

void NxsReader::ExitingBlock(
  NxsString )   /* the name of the block being exited */
    {
    }

void NxsReader::PostBlockReadingHook(
  NxsBlock & /*block*/) 
    {
    }

NxsBlock *NxsReader::CreateBlockFromFactories(const std::string & currBlockName, NxsToken &token, NxsBlockFactory **sourceOfBlock)
    {
    for (BlockFactoryList::iterator fIt = factories.begin(); currBlock == NULL && fIt != factories.end(); ++fIt)
        {
        NxsBlock *b = (*fIt)->GetBlockReaderForID(currBlockName, this, &token);
        if (b)
            {
            if (b->CanReadBlockType(token))
                {
                if (sourceOfBlock)
                    *sourceOfBlock = *fIt;
                b->SetNexus(this);
                return b;
                }
            (*fIt)->BlockError(b);
            }
        }
    return NULL;
    }

void NxsReader::Execute(
  NxsToken  &token,             
  bool      notifyStartStop)    
    {
    bool signalHandlerInstalled = false;
    unsigned numSigInts = 0;
    if (NxsReader::nclCatchesSignals)
        {
        numSigInts = getNumSignalIntsCaught();
        installNCLSignalHandler();
        signalHandlerInstalled = true;
        }
    try {
        CoreExecutionTasks(token, notifyStartStop);
        }
    catch (...)
        {
        if (signalHandlerInstalled)
            uninstallNCLSignalHandler();
        throw;
        }
    if (signalHandlerInstalled)
        {
        uninstallNCLSignalHandler();
        if (numSigInts != getNumSignalIntsCaught())
            throw NxsSignalCanceledParseException("Reading NEXUS content");
        }
    }

void NxsReader::CoreExecutionTasks(
  NxsToken  &token,             /* the token object used to grab NxsReader tokens */
  bool      notifyStartStop)    /* if true, ExecuteStarting and ExecuteStopping will be called */
    {
    unsigned numSigInts = NxsReader::getNumSignalIntsCaught();
    const bool checkingSignals = NxsReader::getNCLCatchesSignals();

    lastExecuteBlocksInOrder.clear();
    currBlock = NULL;

    NxsString errormsg;
    token.SetEOFAllowed(true);

    try
        {
        token.SetLabileFlagBit(NxsToken::saveCommandComments);
        token.GetNextToken();
        }
    catch (NxsException x)
        {
        NexusError(token.errormsg, 0, 0, 0);
        return;
        }

    if (token.Equals("#NEXUS"))
        {
        token.SetLabileFlagBit(NxsToken::saveCommandComments);
        token.GetNextToken();
        }
    else
        {
        errormsg = "Expecting #NEXUS to be the first token in the file, but found ";
        errormsg += token.GetToken();
        errormsg += " instead";
        /*mth changed this to a warning instead of an error  because of the large number
            of files that violate this requirement.
        */
        NexusWarn(errormsg,  NxsReader::AMBIGUOUS_CONTENT_WARNING, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
        }

    if (notifyStartStop)
        ExecuteStarting();
    bool keepReading = true;
    for (;keepReading && !token.AtEOF();)
        {
        if (checkingSignals && NxsReader::getNumSignalIntsCaught() != numSigInts)
            {
            throw NxsSignalCanceledParseException("Reading NEXUS content");
            }
        if (token.Equals("BEGIN"))
            {
            token.SetEOFAllowed(false); /*must exit the block before and EOF*/
            token.GetNextToken();
            token.SetBlockName(token.GetTokenReference().c_str());
            for (currBlock = blockList; currBlock != NULL; currBlock = currBlock->next)
                {
                if (currBlock->CanReadBlockType(token))
                    break;
                }
            NxsString currBlockName = token.GetToken();
            currBlockName.ToUpper();
            NxsBlockFactory * sourceOfBlock = NULL;
            if (currBlock == NULL)
                {
                try
                    {
                    currBlock = CreateBlockFromFactories(currBlockName, token, &sourceOfBlock);
                    }
                catch (NxsException x)
                    {
                    NexusError(x.msg, x.pos, x.line, x.col);
                    token.SetBlockName(0L);
                    token.SetEOFAllowed(true);
                    return;
                    }
                }
            if (currBlock == NULL)
                {
                SkippingBlock(currBlockName);
                if (!ReadUntilEndblock(token, currBlockName))
                    {
                    token.SetBlockName(0L);
                    token.SetEOFAllowed(true);
                    return;
                    }
                }
            else if (currBlock->IsEnabled())
                keepReading = ExecuteBlock(token, currBlockName, currBlock, sourceOfBlock);
            else
                {
                SkippingDisabledBlock(token.GetToken());
                if (sourceOfBlock)
                    sourceOfBlock->BlockSkipped(currBlock);
                if (!ReadUntilEndblock(token, currBlockName))
                    {
                    token.SetBlockName(0L);
                    token.SetEOFAllowed(true);
                    return;
                    }
                }
            currBlock = NULL;
            token.SetEOFAllowed(true);
            token.SetBlockName(0L);
            }   // if (token.Equals("BEGIN"))
        else if (token.Equals("&SHOWALL"))
            {
            for (NxsBlock*  showBlock = blockList; showBlock != NULL; showBlock = showBlock->next)
                DebugReportBlock(*showBlock);
            }
        else if (token.Equals("&LEAVE"))
            break;
        if (keepReading)
            {
            token.SetLabileFlagBit(NxsToken::saveCommandComments);
            token.GetNextToken();
            }
        }
    if (notifyStartStop)
        ExecuteStopping();

    currBlock = NULL;
    }

void NxsReader::ClearContent()
    {
    for (currBlock = blockList; currBlock;)
        {
        currBlock->Reset();
        currBlock = currBlock->next;
        }
    currBlock = blockList;
    blocksInOrder.clear();
    blockPriorities.clear();
    lastExecuteBlocksInOrder.clear();
    blockTypeToBlockList.clear();
    blockTitleHistoryMap.clear();
    blockTitleAliases.clear();
    }


NxsTaxaBlockAPI * NxsReader::GetOriginalTaxaBlock(const NxsTaxaBlockAPI * testB) const
    {
    if (!testB)
        return 0L;
    const std::string idstring("TAXA");
    BlockTypeToBlockList::const_iterator bttblIt = blockTypeToBlockList.find(idstring);
    if (bttblIt == blockTypeToBlockList.end())
        return 0L;
    const BlockReaderList & brl = bttblIt->second;
    const unsigned ntt = testB->GetNumTaxonLabels();
    const std::vector<std::string> testL = testB->GetAllLabels();
    for (BlockReaderList::const_iterator bIt = brl.begin(); bIt != brl.end(); ++bIt)
        {
        const NxsBlock * nb = *bIt;
        const NxsTaxaBlockAPI * prev = (const NxsTaxaBlockAPI *) nb;
        if (prev->GetNumTaxonLabels() == ntt)
            {
            const std::vector<std::string> prevL = prev->GetAllLabels();
            std::vector<std::string>::const_iterator pIt = prevL.begin();
            std::vector<std::string>::const_iterator testIt = testL.begin();

            for (; (testIt != testL.end()) && (pIt != prevL.end()) ; ++testIt, ++pIt)
                {
                if (!NxsString::case_insensitive_equals(testIt->c_str(), pIt->c_str()))
                    break;
                }
            if (testIt == testL.end())
                return const_cast<NxsTaxaBlockAPI *>(prev);
            }
        }

    return 0L;
    }


bool NxsReader::ExecuteBlock(NxsToken &token, const NxsString &currBlockName, NxsBlock *currentBlock, NxsBlockFactory * sourceOfBlock)
    {
    if (!EnteringBlock(currBlockName))
        {
        SkippingBlock(currBlockName);
        if (sourceOfBlock)
            sourceOfBlock->BlockSkipped(currentBlock);
        if (!ReadUntilEndblock(token, currBlockName))
            {
            token.SetBlockName(0L);
            token.SetEOFAllowed(true);
            return false;
            }
        return true;
        }
    this->RemoveBlockFromUsedBlockList(currentBlock);
    currentBlock->Reset();
    // We need to back up currentBlock, because the Read statement might trigger
    // a recursive call to Execute (if the block contains instructions to execute
    // another file, then the same NxsReader object may be used and any member fields (e.g. currentBlock)
    //  could be trashed.
    //
    bool eofFound = false;
    try
        {
        try
            {
            currentBlock->Read(token);
            }
        catch (NxsX_UnexpectedEOF &eofx)
            {
            if (!currentBlock->TolerateEOFInBlock())
                throw eofx;
            NxsString m;
            m << "Unexpected End of file in " << currBlockName << "block";
            currentBlock->WarnDangerousContent(m, token);
            eofFound = true;
            }
        if (destroyRepeatedTaxaBlocks && currBlockName.EqualsCaseInsensitive("TAXA"))
            {
            NxsTaxaBlockAPI * oldTB = this->GetOriginalTaxaBlock((NxsTaxaBlockAPI *) currentBlock);
            if (oldTB)
                {
                const std::string altTitle = currentBlock->GetTitle();
                this->RegisterAltTitle(oldTB, altTitle);
                if (sourceOfBlock)
                    sourceOfBlock->BlockError(currentBlock);
                return true;
                }
            }
        BlockReadHook(currBlockName, currentBlock, &token);
        }
    catch (NxsException &x)
        {
        NxsString m;
        if (currentBlock->errormsg.length() > 0)
            m = currentBlock->errormsg;
        else
            m = x.msg;
        currentBlock->Reset();
        if (sourceOfBlock != 0)
            {

            sourceOfBlock->BlockError(currentBlock);
            }
        else

        token.SetBlockName(0L);
        token.SetEOFAllowed(true);
        currentBlock = NULL;
        NexusError(m, x.pos, x.line, x.col);
        return false;
        }   // catch (NxsException x)
    ExitingBlock(currBlockName);
    PostBlockReadingHook(*currentBlock);
    return !eofFound;
    }

void NxsReader::BlockReadHook(const NxsString &currBlockName, NxsBlock *currentBlock, NxsToken * token)
    {
    VecBlockPtr implied = currentBlock->GetImpliedBlocks();
    for (VecBlockPtr::iterator impIt = implied.begin(); impIt != implied.end(); ++impIt)
        {
        NxsBlock * nb = *impIt;
        NCL_ASSERT(nb);
        NxsString impID = nb->GetID();
        bool storeBlock = true;
        if (destroyRepeatedTaxaBlocks && impID.EqualsCaseInsensitive("TAXA"))
            {
            NxsTaxaBlockAPI * oldTB = this->GetOriginalTaxaBlock((NxsTaxaBlockAPI *) nb);
            if (oldTB)
                {
                storeBlock = ! currentBlock->SwapEquivalentTaxaBlock(oldTB);
                const std::string altTitle = nb->GetTitle();
                this->RegisterAltTitle(oldTB, altTitle);
                if (!storeBlock)
                    {
                    delete nb;
                    }

                }
            }
        if (storeBlock)
            {
            NxsString m;
            m << "storing implied block: " << impID;
            this->statusMessage(m);
            this->AddBlockToUsedBlockList(impID, nb, token);
            }
        }
    NxsString s;
    s << "storing read block: " << currentBlock->GetID();
    this->statusMessage(s);
    this->AddBlockToUsedBlockList(currBlockName, currentBlock, token);
    }

const char * NxsReader::NCLCopyrightNotice()
    {
    return NCL_COPYRIGHT;
    }

const char * NxsReader::NCLHomePageURL()
    {
    return NCL_HOMEPAGEURL;
    }

const char * NxsReader::NCLNameAndVersion()
    {
    return NCL_NAME_AND_VERSION;
    }

void NxsReader::ExecuteStarting()
    {
    }

void NxsReader::ExecuteStopping()
    {
    }

void NxsReader::NexusError(
  NxsString ,   /* the error message to be displayed */
  file_pos  ,   /* the current file position */
  long  ,   /* the current file line */
  long  )   /* the current column within the current file line */
    {
    }

void NxsReader::OutputComment(
  const NxsString &)    /* a comment to be shown on the output */
    {
    }

void NxsReader::SkippingBlock(
  NxsString )   /* the name of the block being skipped */
    {
    }

void NxsReader::SkippingDisabledBlock(
  NxsString )   /* the name of the disabled block being skipped */
    {
    }


bool NxsReader::ReadUntilEndblock(NxsToken &token, const std::string & )
    {
    for (;;)
        {
        token.GetNextToken();
        if (token.Equals("END") || token.Equals("ENDBLOCK"))
            {
            token.GetNextToken();
            if (!token.Equals(";"))
                {
                std::string errormsg = "Expecting ';' after END or ENDBLOCK command, but found ";
                errormsg += token.GetToken();
                errormsg += " instead";
                NexusError(NxsString(errormsg.c_str()), token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
                return false;
                }
            return true;
            }
        else
            token.ProcessAsCommand(NULL);
        }
    }

void NxsReader::SetTaxaBlockFactory(NxsTaxaBlockFactory *f)
    {
    if (this->taxaBlockFactory)
        this->RemoveFactory(this->taxaBlockFactory);
    this->taxaBlockFactory = f;
    if (taxaBlockFactory)
        this->AddFactory(this->taxaBlockFactory);
    }
NxsTaxaBlockAPI *NxsReader::GetLastStoredTaxaBlock()
    {
    const std::string idstring("TAXA");
    NxsBlock * nb = GetLastStoredBlockByID(idstring);
    return static_cast<NxsTaxaBlockAPI *>(nb); //dynamic_cast<NxsTaxaBlockAPI *>(nb);
    }

NxsCharactersBlockAPI *NxsReader::GetLastStoredCharactersBlock()
    {
    const std::string idstring("CHARACTERS");
    NxsBlock * nb = GetLastStoredBlockByID(idstring);
    return static_cast<NxsCharactersBlockAPI *>(nb); //dynamic_cast<NxsCharactersBlockAPI *>(nb);
    }

NxsTreesBlockAPI *NxsReader::GetLastStoredTreesBlock()
    {
    const std::string idstring("TREES");
    NxsBlock * nb = GetLastStoredBlockByID(idstring);
    return static_cast<NxsTreesBlockAPI *>(nb); //dynamic_cast<NxsTreesBlockAPI *>(nb);
    }

NxsBlock *NxsReader::GetLastStoredBlockByID(const std::string &key)
    {
    BlockTypeToBlockList::iterator bttblIt = blockTypeToBlockList.find(key);
    if (bttblIt == blockTypeToBlockList.end())
        return NULL;
    return bttblIt->second.back();
    }

void NxsReader::NewBlockTitleCheckHook(const std::string &blockname, NxsBlock *p, NxsToken *token)
    {
    NxsBlockTitleHistoryMap::iterator mIt = blockTitleHistoryMap.find(blockname);
    if (mIt == blockTitleHistoryMap.end())
        {
        std::list<std::string> mt;
        blockTitleHistoryMap[blockname] = NxsBlockTitleHistory(1, mt);
        mIt = blockTitleHistoryMap.find(blockname);
        NCL_ASSERT(mIt != blockTitleHistoryMap.end());
        }
    NxsBlockTitleHistory & titleHist = mIt->second;
    unsigned n = titleHist.first;
    std::list<std::string> & previousTitles = titleHist.second;
    std::list<std::string>::iterator lsIt;
    std::string pTitle = p->GetTitle();
    std::string origTitle = pTitle;
    NxsString::to_upper(pTitle);
    if (pTitle.empty())
        {
        while (pTitle.empty())
            {
            NxsString autoName = "Untitled ";
            autoName += p->GetID().c_str();
            autoName += " Block ";
            autoName += n++;
            pTitle.assign(autoName.c_str());
            NxsString::to_upper(pTitle);
            lsIt = find(previousTitles.begin(), previousTitles.end(), pTitle);
            if (lsIt == previousTitles.end())
                {
                p->SetTitle(autoName, true);
                titleHist.first = n;
                }
            else
                pTitle.clear();
            }
        }
    else
        {
        lsIt = find(previousTitles.begin(), previousTitles.end(), pTitle);
        if (lsIt != previousTitles.end())
            {
            NxsString msg = "Block titles cannot be repeated. The TITLE ";
            msg += origTitle;
            msg += " has already been used for a ";
            msg += blockname;
            msg += " block.";
            if (token)
                throw NxsException(msg, *token);
            else
                throw NxsException(msg, 0, -1, -1);
            }
        }
    previousTitles.push_back(pTitle);
    }

void NxsReader::AddBlockToUsedBlockList(const std::string &blockTypeID, NxsBlock *p, NxsToken *token)
    {
    NCL_ASSERT(p);
    std::string n;
    if (blockTypeID == "DATA")
        n = std::string("CHARACTERS");
    else
        n = blockTypeID;
    NewBlockTitleCheckHook(n, p, token);
    BlockTypeToBlockList::iterator bttblIt = blockTypeToBlockList.find(n);
    if (bttblIt == blockTypeToBlockList.end())
        blockTypeToBlockList[n] = BlockReaderList(1, p);
    else
        bttblIt->second.push_back(p);
    blocksInOrder.remove(p);
    blocksInOrder.push_back(p);
    if (this->GetBlockPriority(p) < 0)
        AssignBlockPriority(p, 0);

    lastExecuteBlocksInOrder.remove(p);
    lastExecuteBlocksInOrder.push_back(p);
    }

unsigned NxsReader::RemoveBlockFromUsedBlockList(NxsBlock *p)
    {
    unsigned totalDel = 0;
    unsigned before, after;
    std::vector<std::string> keysToDel;
    for (BlockTypeToBlockList::iterator bttblIt = blockTypeToBlockList.begin(); bttblIt != blockTypeToBlockList.end(); ++bttblIt)
        {
        BlockReaderList & brl = bttblIt->second;
        before = (unsigned)brl.size();
        brl.remove(p);
        after = (unsigned)brl.size();
        if (after == 0)
            keysToDel.push_back(bttblIt->first);
        totalDel += before - after;
        }
    for (std::vector<std::string>::const_iterator keyIt = keysToDel.begin(); keyIt != keysToDel.end(); ++keyIt)
        blockTypeToBlockList.erase(*keyIt);
    blocksInOrder.remove(p);
    blockPriorities.erase(p);
    lastExecuteBlocksInOrder.remove(p);
    std::string blockID =  p->GetID();
    NxsBlockTitleHistoryMap::iterator mIt = blockTitleHistoryMap.find(blockID);
    if (mIt != blockTitleHistoryMap.end())
        {
        std::string blockName = p->GetTitle();
        NxsBlockTitleHistory & titleHist = mIt->second;
        std::list<std::string> & previousTitles = titleHist.second;
        std::list<std::string>::iterator ptIt = previousTitles.begin();
        while (ptIt != previousTitles.end())
            {
            if (NxsString::case_insensitive_equals(ptIt->c_str(), blockName.c_str()))
                ptIt = previousTitles.erase(ptIt);
            else
                 ++ptIt;
            }
        }
    return totalDel;
    }

std::set<NxsBlock*> NxsReader::GetSetOfAllUsedBlocks()
    {
    std::set<NxsBlock*> s;
    for (BlockTypeToBlockList::iterator bttblIt = blockTypeToBlockList.begin(); bttblIt != blockTypeToBlockList.end(); ++bttblIt)
        {
        BlockReaderList & brl = bttblIt->second;
        s.insert(brl.begin(), brl.end());
        }
    return s;
    }

void ExceptionRaisingNxsReader::NexusWarn(const std::string &msg, NxsWarnLevel warnLevel, file_pos pos, long line, long col)
    {
    if (warnLevel < currentWarningLevel)
        return;
    if (warnLevel >= this->warningToErrorThreshold)
        {
        NxsString e(msg.c_str());
        throw NxsException(e, pos, line, col);
        }

    if (warnMode == NxsReader::IGNORE_WARNINGS)
        return;
    if (warnMode == NxsReader::WARNINGS_TO_STDERR)
        {
        std::cerr << "\nWarning:  ";
        std::cerr << "\n " << msg << std::endl;
        if (line > 0 || pos > 0)
            std::cerr << "at line " << line << ", column (approximately) " << col << " (file position " << pos << ")\n";
        }
    else if (warnMode != NxsReader::WARNINGS_TO_STDOUT)
        {
        std::cout << "\nWarning:  ";
        if (line > 0 || pos > 0)
            std::cout << "at line " << line << ", column " << col << " (file position " << pos << "):\n";
        std::cout << "\n " << msg << '\n';
        if (line > 0 || pos > 0)
            std::cout << "at line " << line << ", column (approximately) " << col << " (file position " << pos << ')' << std::endl;
        }
    else
        {
        NxsString m("WARNING:\n ");
        m += msg.c_str();
        NexusError(m, pos, line, col);
        }
    }

void ExceptionRaisingNxsReader::SkippingBlock(NxsString blockName)
    {
    if (warnMode == NxsReader::IGNORE_WARNINGS)
        return;
    if (warnMode == NxsReader::WARNINGS_TO_STDERR)
        std::cerr << "[!Skipping unknown block (" << blockName << ")...]" << std::endl;
    else if (warnMode != NxsReader::WARNINGS_TO_STDOUT)
        std::cout << "[!Skipping unknown block (" << blockName << ")...]" << std::endl;
    }

void ExceptionRaisingNxsReader::SkippingDisabledBlock(NxsString blockName)
    {
    if (warnMode == NxsReader::IGNORE_WARNINGS)
        return;
    if (warnMode == NxsReader::WARNINGS_TO_STDERR)
        std::cerr << "[!Skipping disabled block (" << blockName << ")...]" << std::endl;
    else if (warnMode != NxsReader::WARNINGS_TO_STDOUT)
        std::cout << "[!Skipping disabled block (" << blockName << ")...]" << std::endl;
    }

void NxsReader::statusMessage(const std::string & m) const
{
    if (alwaysReportStatusMessages || currentWarningLevel == UNCOMMON_SYNTAX_WARNING) {
        std::cerr << m << std::endl;
    }
}

void NxsReader::ClearUsedBlockList()
    {
    RemoveBlocksFromFactoriesFromUsedBlockLists();
    blocksInOrder.clear();
    blockPriorities.clear();
    lastExecuteBlocksInOrder.clear();
    blockTypeToBlockList.clear();
    }

void NxsReader::AssignBlockPriority(NxsBlock *b, int priorityLevel)
    {
    blockPriorities[b] = priorityLevel;
    }

int NxsReader::GetBlockPriority(NxsBlock *b) const
    {
    std::map<NxsBlock *, int>::const_iterator bIt = blockPriorities.find(b);
    if (bIt == blockPriorities.end())
        return 0;
    return bIt->second;
    }

void NxsReader::DemoteBlocks(int priorityLevel)
    {
    BlockReaderList brl = GetUsedBlocksInOrder();
    BlockReaderList::iterator brlIt = brl.begin();
    for (; brlIt != brl.end(); ++brlIt)
        {
        NxsBlock * b = *brlIt;
        AssignBlockPriority(b, priorityLevel);
        }
    }

---