/*!
Returns true if token NxsString begins with the NxsString `s'. This function should be used instead of the Equals
function if you wish to allow for abbreviations of commands.
*/
bool NxsToken::Begins(
NxsString s, /* the comparison string */
bool respect_case) /* determines whether comparison is case sensitive */
{
unsigned k;
char tokenChar, otherChar;
unsigned slen = (unsigned)s.size();
if (slen > token.size())
return false;
for (k = 0; k < slen; k++)
{
if (respect_case)
{
tokenChar = token[k];
otherChar = s[k];
}
else
{
tokenChar = (char)toupper( token[k]);
otherChar = (char)toupper( s[k]);
}
if (tokenChar != otherChar)
return false;
}
return true;
}
/*----------------------------------------------------------------------------------------------------------------------
| Returns true if token NxsString exactly equals `s'. If abbreviations are to be allowed, either Begins or
| Abbreviation should be used instead of Equals.
*/
bool NxsToken::Equals(
NxsString s, /* the string for comparison to the string currently stored in this token */
bool respect_case) /* if true, comparison will be case-sensitive */
{
unsigned k;
char tokenChar, otherChar;
unsigned slen = (unsigned)s.size();
if (slen != token.size())
return false;
for (k = 0; k < token.size(); k++)
{
if (respect_case)
{
tokenChar = token[k];
otherChar = s[k];
}
else
{
tokenChar = (char)toupper( token[k]);
otherChar = (char)toupper( s[k]);
}
if (tokenChar != otherChar)
return false;
}
return true;
}
/*!
Returns true if token begins with the capitalized portion of `s' and, if token is longer than `s', the remaining
characters match those in the lower-case portion of `s'. The comparison is case insensitive. This function should be
used instead of the Begins function if you wish to allow for abbreviations of commands and also want to ensure that
user does not type in a word that does not correspond to any command.
*/
bool NxsToken::Abbreviation(
NxsString s) /* the comparison string */
{
int k;
int slen = (int)s.size();
int tlen = (int)token.size();
char tokenChar, otherChar;
// The variable mlen refers to the "mandatory" portion
// that is the upper-case portion of s
//
int mlen;
for (mlen = 0; mlen < slen; mlen++)
{
if (!isupper(s[mlen]))
break;
}
// User must have typed at least mlen characters in
// for there to even be a chance at a match
//
if (tlen < mlen)
return false;
// If user typed in more characters than are contained in s,
// then there must be a mismatch
//
if (tlen > slen)
return false;
// Check the mandatory portion for mismatches
//
for (k = 0; k < mlen; k++)
{
tokenChar = (char)toupper( token[k]);
otherChar = s[k];
if (tokenChar != otherChar)
return false;
}
// Check the auxiliary portion for mismatches (if necessary)
//
for (k = mlen; k < tlen; k++)
{
tokenChar = (char)toupper( token[k]);
otherChar = (char)toupper( s[k]);
if (tokenChar != otherChar)
return false;
}
return true;
}
/*--------------------------------------------------------------------------------------------------------------------------
| Returns true if the stored string is a non-case-sensitive copy of the argument `s'. Note: will return true if both the
| stored string and `s' are empty strings.
*/
bool NxsString::EqualsCaseInsensitive(
const NxsString &s) /* the comparison string */
const
{
unsigned k;
unsigned slen = (unsigned)s.size();
unsigned tlen = (unsigned)size();
if (slen != tlen)
return false;
for (k = 0; k < tlen; k++)
{
if ((char)toupper((*this)[k]) != (char)toupper(s[k]))
return false;
}
return true;
}
/*--------------------------------------------------------------------------------------------------------------------------
| Returns true if the string is a abbreviation (or complete copy) of the argument `s'.
*/
bool NxsString::IsStdAbbreviation(
const NxsString &s, /* the string for which the stored string is potentially an abbreviation */
bool respectCase) /* if true, comparison will be case-sensitive */
const
{
if (empty())
return false;
// s is the unabbreviated comparison string
//
const unsigned slen = static_cast<unsigned long>(s.size());
// t is the stored string
//
const unsigned tlen = static_cast<unsigned long>(size());
// t cannot be an abbreviation of s if it is longer than s
//
if (tlen > slen)
return false;
// Examine each character in t and return false (meaning "not an abbreviation")
// if at any point the corresponding character in s is different
//
for (unsigned k = 0; k < tlen; k++)
{
if (respectCase)
{
if ((*this)[k] != s[k])
return false;
}
else if (toupper((*this)[k]) != toupper(s[k]))
return false;
}
return true;
}
/*!
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 virtual
| function in the base class.
*/
void GarliBlock::Read(
NxsToken &token) /* the token used to read from `in' */
{
isEmpty = false;
//if we already read a garli block with a model string, clear it
modelString.clear();
// This should be the semicolon after the block name
//
token.GetNextToken();
if (!token.Equals(";"))
{
errormsg = "Expecting ';' after ";
errormsg += id;
errormsg += " block name, but found ";
errormsg += token.GetToken();
errormsg += " instead";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
for (;;)
{//only allowing three things to happen here
//1. endblock is reached, sucessfully exiting the garli block
//2. something besides an endblock is read. This is interpreted as part of the model string, with minimal error checking
//3. eof is hit before an endblock
token.GetNextToken();
if (token.Abbreviation("ENdblock"))
{
HandleEndblock(token);
break;
}
else if(token.AtEOF() == false){
NxsString s = token.GetToken();
if(s.size() > 1 && (s.IsADouble() == false && s.IsALong() == false)){
errormsg = "Unexpected character(s) in Garli block.\n See manual for model parameter format.";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
if(token.IsPunctuationToken() == false){//toss semicolons and such
modelString += token.GetToken();
modelString += ' ';
}
}
else
{
errormsg = "Unexpected end of file encountered before \"end;\" or\n \"endblock;\" command in Garli block";
throw NxsException(errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
}
}
/*
else if (token.Abbreviation("GarliReader"))
{
HandleGarliReader(token);
}
else if (token.Abbreviation("Help"))
{
HandleHelp(token);
}
else if (token.Abbreviation("Log"))
{
HandleLog(token);
}
else if (token.Abbreviation("EXecute"))
{
HandleExecute(token);
}
else if (token.Abbreviation("Show"))
{
HandleShow(token);
}
else if (token.Abbreviation("Quit"))
{
quit_now = true;
message = "\nGarliReader says goodbye\n";
PrintMessage();
break;
}
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());
}
}
*/
}
/*--------------------------------------------------------------------------------------------------------------------------
| Returns true if the stored string is a case-insensitive abbreviation (or complete copy) of `s' and the stored string
| has all of the characters that are in the initial capitalized portion of `s'. For example if `s' is "KAPpa" then
| "kappa", "kapp", or "kap" (with any capitalization pattern) will return true and all other strings will return false.
| Always returns false if the stored string has length of zero.
*/
bool NxsString::IsCapAbbreviation(
const NxsString &s) /* the string for which the stored string is potentially an abbreviation */
const
{
if (empty())
return false;
// s is the unabbreviated comparison string
//
const unsigned slen = static_cast<unsigned>(s.size());
// t is the stored string
//
const unsigned tlen = static_cast<unsigned>(size());
// If the stored string is longer than s then it cannot be an abbreviation of s
//
if (tlen > slen)
return false;
unsigned k = 0;
for (; k < slen; k++)
{
if (isupper(s[k]))
{
// If still in the uppercase portion of s and we've run out of characters
// in t, then t is not a valid abbrevation of s
//
if (k >= tlen)
return false;
// If kth character in t is not equal to kth character in s, then
// t is not an abbrevation of s
//
char tokenChar = (char)toupper((*this)[k]);
if (tokenChar != s[k])
return false;
}
else if (!isalpha(s[k]))
{
// Get here if we are no longer in the upper case portion of s and
// s[k] is not an alphabetic character. This section is necessary because
// we are dealing with a section of s that is not alphabetical and thus
// we cannot tell whether this should be part of the abbrevation or not
// (i.e. we cannot tell if it is capitalized or not). In this case, we
// pretend that we are still in the upper case portion of s and return
// false if we have run out of characters in t (meaning that the abbreviation
// was too short) or we find a mismatch.
//
if (k >= tlen)
return false;
if ((*this)[k] != s[k])
return false;
}
else
{
// Get here if we are no longer in the upper case portion of s and
// s[k] is an alphabetic character. Just break because we have determined
// that t is in fact a valid abbreviation of s.
//
break;
}
}
// Check the lower case portion of s and any corresponding characters in t for mismatches
// Even though the abbreviation is valid up to this point, it will become invalid if
// any mismatches are found beyond the upper case portion of s
//
for (; k < tlen; k++)
{
const char tokenChar = (char)toupper((*this)[k]);
const char otherChar = (char)toupper(s[k]);
if (tokenChar != otherChar)
return false;
}
return true;
}
