nxsblock.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 "ncl/nxsdefs.h"
#include "ncl/nxsblock.h"
#include "ncl/nxsreader.h"
#include <cstdlib>
using namespace std;

/* i18 */ /*v2.1to2.2 18 */

#if !defined(IGNORE_NXS_ASSERT) && !defined(NDEBUG)
    void ncl_assertion_failed(char const * expr, char const * function, char const * file, long line)
        {
#       if defined (ASSERTS_TO_EXCEPTIONS)
            NxsString err;
#       else
            std::ostream & err(cerr);
#       endif
            err << "\nNCL assertion failed:";
            err << "\n  expr: " << expr;
            err << "\n  func: " << function;
            err << "\n  file: " << file;
            err << "\n  line: " << line ;
#       if defined (ASSERTS_TO_EXCEPTIONS)
            throw NxsNCLAPIException(err);
#       else
            std::cerr << std::endl;
            std::exit(1);
#       endif
        }
#endif



unsigned NxsLabelToIndicesMapper::GetIndicesFromSets(const std::string &label,
  NxsUnsignedSet *inds,
  const NxsUnsignedSetMap & itemSets)
    {
    const unsigned labelLen = (unsigned)label.length();
    NxsUnsignedSetMap::const_iterator csIt = itemSets.begin();
    for (; csIt != itemSets.end(); ++csIt)
        {
        const NxsString & csLabel = csIt->first;
        if (labelLen == csLabel.length() && NxsString::case_insensitive_equals(label.c_str(), csLabel.c_str()))
            {
            const std::set<unsigned> & csSet = csIt->second;
            if (inds)
                inds->insert(csSet.begin(), csSet.end());
            return (unsigned)csSet.size();
            }
        }
    return 0;
    }

unsigned NxsLabelToIndicesMapper::GetIndicesFromSetOrAsNumber(const std::string &label,
  NxsUnsignedSet *inds,
  const NxsUnsignedSetMap & itemSets,
  const unsigned maxInd,
  const char * itemType) /* "tree", "character"... */
    {
    unsigned n = GetIndicesFromSets(label, inds, itemSets);
    if (n > 0)
        return n;
    long i;
    if (!NxsString::to_long(label.c_str(), &i))
        {
        NxsString emsg;
        emsg << "Expecting a  number or " << itemType << " label, found " <<  label;
        throw NxsException(emsg);
        }
    i--;
    if (i > (long)maxInd  || i < 0)
        {
        NxsString emsg = "Expecting a ";
        emsg << itemType << " name or a number corresponding to a " << itemType << "\'s number (a number from 1 to ";
        emsg << maxInd + 1 << "). Found " << label;
        throw NxsException(emsg);
        }
    unsigned asu = (unsigned) (i);
    if (inds)
        inds->insert(asu);
    return 1;
    }

void NxsBlock::WarnDangerousContent(const std::string &s, const NxsToken &token)
    {
    if (nexusReader)
        nexusReader->NexusWarnToken(s, NxsReader::PROBABLY_INCORRECT_CONTENT_WARNING, token);
    else
        throw NxsException(s, token);
    }

void NxsBlock::WarnDangerousContent(const std::string &s, const ProcessedNxsToken &token)
    {
    if (nexusReader)
        nexusReader->NexusWarnToken(s, NxsReader::PROBABLY_INCORRECT_CONTENT_WARNING, token);
    else
        throw NxsException(s, token);
    }
void NxsBlock::SkipCommand(NxsToken & token)
    {
    if (nexusReader)
        {
        errormsg = "Skipping command: ";
        errormsg << token.GetTokenReference();
        nexusReader->NexusWarnToken(errormsg, NxsReader::SKIPPING_CONTENT_WARNING, token);
        errormsg.clear();
        }
    if (!token.Equals(";"))
        SkippingCommand(token.GetToken());
    if (storeSkippedCommands)
        {
        ProcessedNxsCommand pnc;
        token.ProcessAsCommand(&pnc);
        skippedCommands.push_back(pnc);
        }
    else
        token.ProcessAsCommand(NULL);
    }

void NxsBlock::WriteSkippedCommands(std::ostream & out) const
    {
    for (list<ProcessedNxsCommand>::const_iterator cIt = skippedCommands.begin(); cIt != skippedCommands.end(); ++cIt)
        {
        if (WriteCommandAsNexus(out, *cIt))
            out << '\n';
        }

    }



NxsBlock::NxsCommandResult NxsBlock::HandleBasicBlockCommands(NxsToken & token)
    {
    if (token.Equals("TITLE"))
        {
        HandleTitleCommand(token);
        return NxsBlock::NxsCommandResult(HANDLED_COMMAND);
        }
    if (false && token.Equals("BLOCKID")) /*now we are skipping this to put it at the end of blocks*/
        {
        HandleBlockIDCommand(token);
        return NxsBlock::NxsCommandResult(HANDLED_COMMAND);
        }
    if (token.Equals("LINK") && this->ImplementsLinkAPI())
        {
        HandleLinkCommand(token);
        return NxsBlock::NxsCommandResult(HANDLED_COMMAND);
        }
    if (token.Equals("END") || token.Equals("ENDBLOCK"))
        {
        HandleEndblock(token);
        return NxsBlock::NxsCommandResult(STOP_PARSING_BLOCK);
        }
    return NxsBlock::NxsCommandResult(UNKNOWN_COMMAND);
    }

void NxsBlock::HandleTitleCommand(NxsToken & token)
    {
    token.GetNextToken();
    if (token.Equals(";"))
        GenerateUnexpectedTokenNxsException(token, "a title for the block");
    if (!title.empty() && nexusReader)
        {
        errormsg = "Multiple TITLE commands were encountered the title \"";
        errormsg += title;
        errormsg += "\" will be replaced by \"";
        errormsg += token.GetToken() ;
        errormsg += '\"';
        nexusReader->NexusWarnToken(errormsg, NxsReader::OVERWRITING_CONTENT_WARNING, token);
        errormsg.clear();
        }
    title = token.GetToken();
    /* i19 */ /*v2.1to2.2 19 */
    autoTitle = false;
    DemandEndSemicolon(token, "TITLE");
    }

void NxsBlock::HandleBlockIDCommand(NxsToken & token)
    {
    token.GetNextToken();
    if (token.Equals(";"))
        GenerateUnexpectedTokenNxsException(token, "an id for the block");
    blockIDString = token.GetToken();
    DemandEndSemicolon(token, "BLOCKID");
    }

void NxsBlock::HandleLinkCommand(NxsToken & )
    {
    throw NxsUnimplementedException("NxsBlock::HandleLinkCommand");
    }
void NxsBlock::WriteBasicBlockCommands(std::ostream &out) const
    {
    WriteTitleCommand(out);
    WriteBlockIDCommand(out);
    if (this->ImplementsLinkAPI())
        WriteLinkCommand(out);
    }

NxsBlock::NxsBlock()
    :isEmpty(true),
    isEnabled(true),
    isUserSupplied(false),
    nexusReader(NULL),
    next(NULL),
    linkAPI(false),
    storeSkippedCommands(true)
    {
    }

void NxsBlock::DemandIsAtEquals(NxsToken &token, const char *contextString) const
    {
    if (!token.Equals("="))
        {
        errormsg = "Expecting '=' ";
        if (contextString)
            errormsg.append(contextString);
        errormsg << " but found " << token.GetToken() << " instead";
        throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
        }
    }

void NxsBlock::DemandEquals(ProcessedNxsCommand::const_iterator & tokIt, const ProcessedNxsCommand::const_iterator & endIt, const char *contextString) const
    {
    ++tokIt;
    if (tokIt == endIt)
        {
        errormsg = "Expecting '=' ";
        if (contextString)
            errormsg.append(contextString);
        errormsg << " but found ; instead";
        --tokIt;
        throw NxsException(errormsg, *tokIt);
        }
    if (!tokIt->Equals("="))
        {
        errormsg = "Expecting '=' ";
        if (contextString)
            errormsg.append(contextString);
        errormsg << " but found " << tokIt->GetToken() << " instead";
        throw NxsException(errormsg, *tokIt);
        }
    }


void NxsBlock::GenerateNxsException(NxsToken &token, const char *message) const
    {
    if (message)
        errormsg = message;
    throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
    }

void NxsBlock::GenerateUnexpectedTokenNxsException(NxsToken &token, const char *expected) const
    {
    errormsg = "Unexpected token";
    if (expected)
        {
        errormsg += ". Expecting ";
        errormsg += expected;
        errormsg += ", but found: ";
        }
    else
        {
        errormsg += ": ";
        }
    errormsg += token.GetToken();
    throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
    }



void NxsBlock::HandleEndblock(
  NxsToken &token)  /* the token used to read from in */
    {
    DemandEndSemicolon(token, "END or ENDBLOCK");
    }

NxsBlock::~NxsBlock()
    {
    if (nexusReader)
        nexusReader->Detach(this);
    }

unsigned NxsBlock::CharLabelToNumber(
  NxsString) NCL_COULD_BE_CONST /* the character label to be translated to the character's number */ /*v2.1to2.2 1 */
    {
    return 0;
    }

void NxsBlock::Disable()
    {
    isEnabled = false;
    }

void NxsBlock::Enable()
    {
    isEnabled = true;
    }

bool NxsBlock::IsEnabled() NCL_COULD_BE_CONST /*v2.1to2.2 1 */
    {
    return isEnabled;
    }

bool NxsBlock::IsUserSupplied() NCL_COULD_BE_CONST /*v2.1to2.2 1 */
    {
    return isUserSupplied;
    }

bool NxsBlock::IsEmpty() NCL_COULD_BE_CONST /*v2.1to2.2 1 */
    {
    return isEmpty;
    }

NxsString NxsBlock::GetID() const
    {
    return id;
    }

void NxsBlock::Read(
  NxsToken &)   /* the NxsToken to use for reading block */
    {
    }

void NxsBlock::Reset()
    {
    title = std::string();
    /* i19 */ /*v2.1to2.2 19 */
    autoTitle = false;
    // Reset base class data members that could have changed
    //
    errormsg.clear();
    isEnabled      = true;
    isEmpty        = true;
    isUserSupplied = false;
    skippedCommands.clear();

    }

void NxsBlock::Report(
  std::ostream &) NCL_COULD_BE_CONST /* the output stream to which the report is sent */ /*v2.1to2.2 1 */
    {
    }

void NxsBlock::SkippingCommand(
  NxsString )   /* the name of the command being skipped */
    {
    }

unsigned NxsBlock::TaxonLabelToNumber(
  NxsString ) const /* the taxon label to be translated to a taxon number */
    {
    return 0;
    }

VecBlockPtr NxsBlock::GetImpliedBlocks()
    {
    return VecBlockPtr();
    }

VecConstBlockPtr NxsBlock::GetImpliedBlocksConst() const
    {
    return VecConstBlockPtr();
    }

NxsBlock * NxsBlock::CloneBlock(
  NxsBlockMapper & 
  ) const
    {
    throw NxsUnimplementedException(NxsString("CloneBlock"));
    }

void NxsBlock::WriteAsNexus(std::ostream &) const
    {
    throw NxsUnimplementedException(NxsString("NxsBlock::WriteAsNexus"));
    }

void NxsBlock::WriteTitleCommand(std::ostream &out) const
    {
    const std::string &t = this->GetInstanceName();
    if (t.length() > 0)
        out << "    TITLE " << NxsString::GetEscaped(t) << ";\n";
    }

void NxsBlock::WriteBlockIDCommand(std::ostream &out) const
    {
    const std::string & t = this->blockIDString;
    if (t.length() > 0)
        out << "    BLOCKID " << NxsString::GetEscaped(t) << ";\n";
    }

void NxsBlock::WriteLinkCommand(std::ostream &) const
    {
    throw NxsUnimplementedException("NxsBlock::WriteLinkCommand");
    }

std::string GetBlockIDTitleString(NxsBlock &b)
    {
    const std::string &t = b.GetInstanceName();
    std::string r = b.GetID();
    r.append(" block");
    if (t.length() > 0)
        {
        r.append(" (");
        r.append(t);
        r.append(")");
        }
    return r;
    }

bool NxsBlock::ImplementsLinkAPI() const
    {
    return this->linkAPI;
    }

void NxsBlock::SetImplementsLinkAPI(bool v)
    {
    this->linkAPI = v;
    }
unsigned NxsBlock::DemandPositiveInt(NxsToken &token, const char *contextString) const
    {
    return NxsToken::DemandPositiveInt(token, this->errormsg, contextString);
    }

void NxsBlock::DemandEndSemicolon(NxsToken &token, const char *contextString) const
    {
    NxsToken::DemandEndSemicolon(token, this->errormsg, contextString);
    }

---