/*!
Called from HandleMatrix function to read in the next state. Returns true if next token encountered is a comma,
false otherwise. A comma signals the end of data for the current taxon in an UNALIGNED block.
*/
bool NxsUnalignedBlock::HandleNextState(
NxsToken & token, /* is the token used to read from `in' */
unsigned taxNum, /* is the row in range [0..ntax) (used for error reporting only) */
unsigned charNum, /* is the column (used for error reporting only) */
NxsDiscreteStateRow & row, const NxsString &nameStr) /* is the container for storing new state */
{
token.SetLabileFlagBit(NxsToken::parentheticalToken);
token.SetLabileFlagBit(NxsToken::curlyBracketedToken);
token.SetLabileFlagBit(NxsToken::singleCharacterToken);
token.GetNextToken();
if (token.Equals(",") || token.Equals(";"))
return false;
const NxsString stateAsNexus = token.GetToken();
const NxsDiscreteStateCell stateCode = mapper.EncodeNexusStateString(stateAsNexus, token, taxNum, charNum, NULL, nameStr);
if (charNum < row.size())
row[charNum] = stateCode;
else
{
while (charNum < row.size())
row.push_back(NXS_INVALID_STATE_CODE);
row.push_back(stateCode);
}
return true;
}
/*! used internally to do most of the work of Execute() */
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;
}
/*!
Called when FORMAT command needs to be parsed from within the DIMENSIONS block. Deals with everything after the
token FORMAT up to and including the semicolon that terminates the FORMAT command.
*/
void NxsUnalignedBlock::HandleFormat(
NxsToken & token) /* is the token used to read from `in' */
{
bool standardDataTypeAssumed = false;
bool ignoreCaseAssumed = false;
for (;;)
{
token.GetNextToken();
if (token.Equals("DATATYPE"))
{
DemandEquals(token, "after keyword DATATYPE");
// This should be one of the following: STANDARD, DNA, RNA, NUCLEOTIDE or PROTEIN
token.GetNextToken();
if (token.Equals("STANDARD"))
datatype = NxsCharactersBlock::standard;
else if (token.Equals("DNA"))
datatype = NxsCharactersBlock::dna;
else if (token.Equals("RNA"))
datatype = NxsCharactersBlock::rna;
else if (token.Equals("NUCLEOTIDE"))
datatype = NxsCharactersBlock::nucleotide;
else if (token.Equals("PROTEIN"))
datatype = NxsCharactersBlock::protein;
else
{
errormsg = token.GetToken();
errormsg += " is not a valid DATATYPE within a ";
errormsg += NCL_BLOCKTYPE_ATTR_NAME;
errormsg += " block";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
if (standardDataTypeAssumed && datatype != NxsCharactersBlock::standard)
{
errormsg = "DATATYPE must be specified first in FORMAT command";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
originalDatatype = datatype;
ResetSymbols();
}
else if (token.Equals("RESPECTCASE"))
{
if (ignoreCaseAssumed)
{
errormsg = "RESPECTCASE must be specified before MISSING and SYMBOLS in FORMAT command";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
standardDataTypeAssumed = true;
respectingCase = true;
}
else if (token.Equals("MISSING"))
{
DemandEquals(token, "after keyword MISSING");
// This should be the missing data symbol (single character)
token.GetNextToken();
if (token.GetTokenLength() != 1)
{
errormsg = "MISSING symbol should be a single character, but ";
errormsg += token.GetToken();
errormsg += " was specified";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
else if (token.IsPunctuationToken() && !token.IsPlusMinusToken())
{
errormsg = "MISSING symbol specified cannot be a punctuation token (";
errormsg += token.GetToken();
errormsg += " was specified)";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
else if (token.IsWhitespaceToken())
{
errormsg = "MISSING symbol specified cannot be a whitespace character (";
errormsg += token.GetToken();
errormsg += " was specified)";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
missing = token.GetToken()[0];
ignoreCaseAssumed = true;
standardDataTypeAssumed = true;
}
else if (token.Equals("SYMBOLS") || token.Equals("SYMBOL"))
{
NxsDiscreteStateCell numDefStates;
unsigned maxNewStates;
switch(datatype)
{
case NxsCharactersBlock::dna:
case NxsCharactersBlock::rna:
case NxsCharactersBlock::nucleotide:
numDefStates = 4;
maxNewStates = NCL_MAX_STATES-4;
break;
case NxsCharactersBlock::protein:
numDefStates = 21;
maxNewStates = NCL_MAX_STATES-21;
break;
default:
numDefStates = 0; // replace symbols list for standard datatype
symbols[0] = '\0';
maxNewStates = NCL_MAX_STATES;
}
DemandEquals(token, "after keyword SYMBOLS");
// This should be the symbols list
token.SetLabileFlagBit(NxsToken::doubleQuotedToken);
token.GetNextToken();
token.StripWhitespace();
unsigned numNewSymbols = token.GetTokenLength();
if (numNewSymbols > maxNewStates)
{
errormsg = "SYMBOLS defines ";
errormsg += numNewSymbols;
errormsg += " new states but only ";
errormsg += maxNewStates;
errormsg += " new states allowed for this DATATYPE";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
NxsString to = token.GetToken();
unsigned tlen = (unsigned)to.size();
NxsString processedS;
// Check to make sure user has not used any symbols already in the
// default symbols list for this data type
for (unsigned i = 0; i < tlen; i++)
{
if (IsInSymbols(to[i]))
{
errormsg = "The character ";
errormsg << to[i] << " defined in SYMBOLS is predefined for this DATATYPE and shoud not occur in a SYMBOLS subcommand of a FORMAT command.";
if (nexusReader)
{
nexusReader->NexusWarnToken(errormsg, NxsReader::SKIPPING_CONTENT_WARNING, token);
errormsg.clear();
}
}
else
processedS += to[i];
}
// If we've made it this far, go ahead and add the user-defined
// symbols to the end of the list of predefined symbols
symbols.append(processedS);
ignoreCaseAssumed = true;
standardDataTypeAssumed = true;
}
else if (token.Equals("EQUATE"))
{
DemandEquals(token, "after keyword EQUATE");
// This should be a double-quote character
token.GetNextToken();
if (!token.Equals("\""))
{
errormsg = "Expecting '\"' after keyword EQUATE but found ";
errormsg += token.GetToken();
errormsg += " instead";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
// Loop until second double-quote character is encountered
for (;;)
{
token.GetNextToken();
if (token.Equals("\""))
break;
// If token is not a double-quote character, then it must be the equate symbol (i.e., the
// character to be replaced in the data matrix)
if (token.GetTokenLength() != 1)
{
errormsg = "Expecting single-character EQUATE symbol but found ";
errormsg += token.GetToken();
errormsg += " instead";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
// Check for bad choice of equate symbol
NxsString t = token.GetToken();
const char ch = t[0];
bool badEquateSymbol = false;
// The character '^' cannot be an equate symbol
if (ch == '^')
badEquateSymbol = true;
// Equate symbols cannot be punctuation (except for + and -)
if (token.IsPunctuationToken() && !token.IsPlusMinusToken())
badEquateSymbol = true;
// Equate symbols cannot be same as matchchar, missing, or gap
if (ch == missing || ch == gap)
badEquateSymbol = true;
// Equate symbols cannot be one of the state symbols currently defined
if (IsInSymbols(ch))
badEquateSymbol = true;
if (badEquateSymbol)
{
errormsg = "EQUATE symbol specified (";
errormsg += token.GetToken();
errormsg += ") is not valid; must not be same as missing, \nmatchchar, gap, state symbols, or any of the following: ()[]{}/\\,;:=*'\"`<>^";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
NxsString k = token.GetToken();
DemandEquals(token, "in EQUATE definition");
// This should be the token to be substituted in for the equate symbol
token.SetLabileFlagBit(NxsToken::parentheticalToken);
token.SetLabileFlagBit(NxsToken::curlyBracketedToken);
token.GetNextToken();
NxsString v = token.GetToken();
// Add the new equate association to the equates list
equates[ch] = v;
}
standardDataTypeAssumed = true;
}
else if (token.Equals("LABELS"))
{
labels = true;
standardDataTypeAssumed = true;
}
else if (token.Equals("NOLABELS"))
{
labels = false;
standardDataTypeAssumed = true;
}
else if (token.Equals(";"))
{
break;
}
}
ResetDatatypeMapper();
}
/*----------------------------------------------------------------------------------------------------------------------
| This function provides the ability to read everything following the block name (which is read by the NxsReader
| object) to the end or endblock statement. Characters are read from the input stream in. Overrides the abstract
| virtual function in the base class.
*/
void NxsTaxaBlock::Read(
NxsToken &token) /* the token used to read from in */
{
ntax = 0;
int nominal_ntax = 0;
isEmpty = false;
isUserSupplied = true;
// This should be the semicolon after the block name
//
token.GetNextToken();
if (!token.Equals(";"))
{
errormsg = "Expecting ';' after TAXA block name, but found ";
errormsg += token.GetToken();
errormsg += " instead";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
for (;;)
{
token.GetNextToken();
if (token.Equals("DIMENSIONS"))
{
// This should be the NTAX keyword
//
token.GetNextToken();
if (!token.Equals("NTAX"))
{
errormsg = "Expecting NTAX keyword, but found ";
errormsg += token.GetToken();
errormsg += " instead";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
// This should be the equals sign
//
token.GetNextToken();
if (!token.Equals("="))
{
errormsg = "Expecting '=', but found ";
errormsg += token.GetToken();
errormsg += " instead";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
// This should be the number of taxa
//
token.GetNextToken();
nominal_ntax = atoi(token.GetToken().c_str());
if (nominal_ntax <= 0)
{
errormsg = "NTAX should be greater than zero (";
errormsg += token.GetToken();
errormsg += " was specified)";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
// This should be the terminating semicolon
//
token.GetNextToken();
if (!token.Equals(";"))
{
errormsg = "Expecting ';' to terminate DIMENSIONS command, but found ";
errormsg += token.GetToken();
errormsg += " instead";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
} // if (token.Equals("DIMENSIONS"))
else if (token.Equals("TAXLABELS"))
{
if (nominal_ntax <= 0)
{
errormsg = "NTAX must be specified before TAXLABELS command";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
for (unsigned i = 0; (int)i < nominal_ntax; i++)
{
token.SetLabileFlagBit(NxsToken::hyphenNotPunctuation + NxsToken::preserveUnderscores);
token.GetNextToken();
//@pol should check to make sure this is not punctuation
AddTaxonLabel(token.GetToken());
}
// This should be terminating semicolon
//
token.GetNextToken();
if (!token.Equals(";"))
{
errormsg = "Expecting ';' to terminate TAXLABELS command, but found ";
errormsg += token.GetToken();
errormsg += " instead";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
} // if (token.Equals("TAXLABELS"))
else if (token.Equals("END") || token.Equals("ENDBLOCK"))
{
// Get the semicolon following END
//
token.GetNextToken();
if (!token.Equals(";"))
{
errormsg = "Expecting ';' to terminate the ENDBLOCK command, but found ";
errormsg += token.GetToken();
errormsg += " instead";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
break;
} // if (token.Equals("END") || token.Equals("ENDBLOCK"))
else
{
SkippingCommand(token.GetToken());
do
{
token.GetNextToken();
}
while (!token.AtEOF() && !token.Equals(";"));
if (token.AtEOF())
{
errormsg = "Unexpected end of file encountered";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
} // token not END, ENDBLOCK, TAXLABELS, or DIMENSIONS
} // GetNextToken loop
}
