/*
* MrBayes 2.0
*
* John P. Huelsenbeck
* Department of Biology
* University of Rochester
* Rochester, NY 14627
*
* johnh@brahms.biology.rochester.edu
*
* Fredrik Ronquist
* Dept. Systematic Zoology
* Evolutionary Biology Centre
* Uppsala University
* Norbyv. 18D, SE-752 36 Uppsala, Sweden
*
* fredrik.ronquist@ebc.uu.se
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <string.h>
#include <ctype.h>
#include "jph.h"
#include "tree.h"
#include "command.h"
#include "mcmc.h"
#define NUMCOMMANDS 176
#define NUMTOKENCHARS 14
#define HIERARCHYSIZE 610
#define SCREENWIDTH 60
#define SCREENWIDTH2 61
#define SCREENHEIGTH 15
#define HEADER_SIZE 1000
#define MAX_PARTITIONS 10000
#define NO_ACTION -1
#define ERROR_ACTION -2
#define EQUALSIGN 1
#define COLON 2
#define SEMICOLON 3
#define COMMA 4
#define POUNDSIGN 5
#define QUESTIONMARK 6
#define DASH 7
#define LEFTPAR 8
#define RIGHTPAR 9
#define LEFTCOMMENT 10
#define RIGHTCOMMENT 11
#define ALPHA 12
#define NUMBER 13
#define RETURNSYMBOL 14
#define ASTERISK 15
#define BACKSLASH 16
#define FORWARDSLASH 17
#define EXCLAMATIONMARK 18
#define PERCENT 19
#define AMPERSTAND 20
#define TILDE 21
#define PLUS 22
#define CARAT 23
#define DOLLARSIGN 24
#define ATSIGN 25
#define PIPESIGN 26
#define LEFTCURLY 27
#define RIGHTCURLY 28
#define UNKNOWN_TOKEN_TYPE 29
#define ANYTOKEN 30
#define CMD_EXECUTE 0
#define CMD_QUIT 1
#define CMD_ENTER_INPUT_FILE_NAME1 2
#define CMD_ENTER_INPUT_FILE_NAME2 3
#define CMD_INIT_NTAX 4
#define CMD_INIT_NCHAR 5
#define CMD_INIT_DATA_BLOCK 6
#define CMD_ALLOC_MATRIX 7
#define CMD_INIT_GAPCHAR 8
#define CMD_INIT_MATCHCHAR 9
#define CMD_INIT_MISSINGCHAR 10
#define CMD_INIT_INTERLEAVE 11
#define CMD_INIT_DATATYPE 12
#define CMD_EXIT_DATA_BLOCK 13
#define CMD_INIT_READ_MATRIX 14
#define CMD_FILL_MATRIX 15
#define CMD_FINISH_READ_MATRIX 16
#define CMD_ENTER_HELP_Q 17
#define CMD_GET_USER_SOME_HELP 18
#define CMD_INIT_HELP 19
#define CMD_SET_NST 20
#define CMD_SET_RATES 21
#define CMD_SET_BASE_FREQ 22
#define CMD_SET_CLOCK 23
#define CMD_END_NST 24
#define CMD_INIT_TRATIO 25
#define CMD_INIT_REVRATES 26
#define CMD_INIT_REVRATES2 27
#define CMD_INIT_REVRATES3 28
#define CMD_INIT_NONREVRATES 29
#define CMD_INIT_NONREVRATES2 30
#define CMD_INIT_NONREVRATES3 31
#define CMD_INIT_SHAPE 32
#define CMD_INIT_SITERATES 33
#define CMD_INIT_SITERATES2 34
#define CMD_INIT_PARTITION 35
#define CMD_INIT_CHARSET_NAME 36
#define CMD_INIT_CHARSET_NAME2 37
#define CMD_INIT_CHARSET 38
#define CMD_INIT_CHARSET2 39
#define CMD_ENTER_MRBAYES_BLOCK 40
#define CMD_EXIT_MRBAYES_BLOCK 41
#define CMD_INIT_EXCLUDE 42
#define CMD_EXCLUDE 43
#define CMD_EXCLUDE2 44
#define CMD_EXCLUDE3 45
#define CMD_EXCLUDE4 46
#define CMD_DEF_PARTITION 47
#define CMD_PARTITION 48
#define CMD_PARTITION2 49
#define CMD_PARTITION3 50
#define CMD_PARTITION4 51
#define CMD_PARTITION5 52
#define CMD_PARTITION6 53
#define CMD_DEF_OUTGROUP1 54
#define CMD_DEF_OUTGROUP2 55
#define CMD_SHOW_CHAR_STAT 56
#define CMD_CALIBRATION1 57
#define CMD_CALIBRATION2 58
#define CMD_CALIBRATION3 59
#define CMD_CALIBRATION4 60
#define CMD_CALIBRATION5 61
#define CMD_CALIBRATION6 62
#define CMD_CALIBRATION7 63
#define CMD_CONSTRAINT1 64
#define CMD_CONSTRAINT2 65
#define CMD_CONSTRAINT3 66
#define CMD_CONSTRAINT4 67
#define CMD_CONSTRAINT5 68
#define CMD_INIT_INCLUDE 69
#define CMD_INCLUDE 70
#define CMD_INCLUDE2 71
#define CMD_INCLUDE3 72
#define CMD_INCLUDE4 73
#define CMD_DELETE1 74
#define CMD_DELETE2 75
#define CMD_DELETE3 76
#define CMD_RESTORE1 77
#define CMD_RESTORE2 78
#define CMD_RESTORE3 79
#define CMD_MCMC 80
#define CMD_MCMC1 81
#define CMD_MCMC2 82
#define CMD_MCMC3 83
#define CMD_MCMC4 84
#define CMD_MCMC5 85
#define CMD_MCMC6 86
#define CMD_MCMC7 87
#define CMD_MCMC8 88
#define CMD_MCMC9 89
#define CMD_PRIOR1 90
#define CMD_PRIOR2 91
#define CMD_PRIOR3 92
#define CMD_PRIOR4 93
#define CMD_PRIOR5 94
#define CMD_PRIOR6 95
#define CMD_PRIOR7 96
#define CMD_PRIOR8 97
#define CMD_PRIOR9 98
#define CMD_PRIOR10 99
#define CMD_PRIOR11 100
#define CMD_PRIOR12 101
#define CMD_PRIOR13 102
#define CMD_PRIOR14 103
#define CMD_PRIOR15 104
#define CMD_PRIOR16 105
#define CMD_PRIOR17 106
#define CMD_PRIOR18 107
#define CMD_PRIOR19 108
#define CMD_PRIOR20 109
#define CMD_PRIOR21 110
#define CMD_PRIOR22 111
#define CMD_PRIOR23 112
#define CMD_PRIOR24 113
#define CMD_PRIOR25 114
#define CMD_PRIOR26 115
#define CMD_PRIOR27 116
#define CMD_TREE 117
#define CMD_TREE1 118
#define CMD_TREE2 119
#define CMD_TREE3 120
#define CMD_TREE4 121
#define CMD_TREE5 122
#define CMD_TREE6 123
#define CMD_TREE7 124
#define CMD_TREE8 125
#define CMD_SHOWUSERTREE 126
#define CMD_INIT_ENFORCECAL 127
#define CMD_INIT_ENFORCECON 128
#define CMD_INIT_INFERANC 129
#define CMD_INIT_NCAT 130
#define CMD_ROOT_TREE 131
#define CMD_DEROOT_TREE 132
#define CMD_SHOWNODES 133
#define CMD_SAVEBRLENS 134
#define CMD_SET_SEQ_ERROR 135
#define CMD_SET_SP_RATE 136
#define CMD_SET_EX_RATE 137
#define CMD_SET_SAMP_FRAC 138
#define CMD_SUMT_FILENAME 139
#define CMD_SUMT_BURN 140
#define CMD_SUMT_READFILE 141
#define CMD_TRANS_INIT 142
#define CMD_TRANS_NEW_NM 143
#define CMD_TRANS_OLD_NM 144
#define CMD_TRANS_COMMA 145
#define CMD_TRANS_END 146
#define CMD_SUM_TREE 147
#define CMD_SUM_TREE1 148
#define CMD_SUM_TREE2 149
#define CMD_SUM_TREE3 150
#define CMD_SUM_TREE4 151
#define CMD_SUM_TREE5 152
#define CMD_SUM_TREE6 153
#define CMD_SUM_TREE7 154
#define CMD_SUM_TREE8 155
#define CMD_INIT_TREE_BLK 156
#define CMD_SUM_TREE_END 157
#define CMD_SUMT_HALFCOMP 158
#define CMD_SUMT_ALLCOMP 159
#define CMD_SUMP_FILENAME 160
#define CMD_SUMP_BURN 161
#define CMD_SUMP_READFILE 162
#define CMD_SUM_PARM1 163
#define CMD_SUM_PARM2 164
#define CMD_SUM_PARM3 165
#define CMD_SUM_PARM4 166
#define CMD_SUM_PARM5 167
#define CMD_SUM_PARM6 168
#define CMD_SUM_PARM7 169
#define CMD_SUM_PARM8 170
#define CMD_SUM_PARM9 171
#define CMD_SUM_PARM10 172
#define CMD_AUTOCLOSE1 173
#define CMD_AUTOCLOSE2 174
#define CMD_NPERB 175
#define CMD_MCMCP 176
#define CMD_SET_AAMODEL1 177
#define CMD_SET_AAMODEL2 178
#define CMD_SET_AAMODEL3 179
#define CMD_SET_AAMODEL4 180
#define CMD_SET_AAMODEL5 181
#define CMD_SET_ANCFILE1 182
#define CMD_SET_ANCFILE2 183
#define CMD_SET_CODON1 184
#define CMD_SET_CODON2 185
#define CMD_SET_OMEGAVAR1 186
#define CMD_SET_OMEGAVAR2 187
#define CMD_SET_OMEGAVAR3 188
#define CMD_SET_OMEGAVAR4 189
#define CMD_SET_OMEGAVAR5 190
#define CMD_SET_OMEGA 191
#define CMD_OMEGAPR1 192
#define CMD_OMEGAPR2 193
#define CMD_OMEGAPR3 194
#define CMD_OMEGAPR4 195
#define CMD_OMEGAPR5 196
#define CMD_OMEGAPR6 197
#define CMD_SET_CODE 198
#define CMD_INFERSEL_YES 199
#define CMD_INFERSEL_NO 200
#define CMD_INIT_LAG1 201
#define CMD_INIT_LAG2 202
#define CMD_SET_LAG_PR1 203
#define CMD_SET_LAG_PR2 204
#define CMD_SET_LAG_PR3 205
#define CMD_SET_LAG_PR4 206
#define CMD_SET_INFERRATES1 207
#define CMD_SET_INFERRATES2 208
#define CMD_SET_COVARION1 209
#define CMD_SET_COVARION2 210
#define CMD_SET_PROPS1 211
#define CMD_SET_PROPS2 212
#define CMD_SET_COVTYPE 213
#define CMD_SET_CODING 214
#define CMD_SET_STATE_PR1 215
#define CMD_SET_STATE_PR2 216
#define CMD_SET_MOVE_PROPS 217
#define CMD_SET_MCMC_BURN 218
#define CMD_SET_CYCLEFREQ 219
#define CMD_SET_CALCPSEUDOBF 220
#define CMD_SET_PARS_CRIT 221
#define CMD_SET_TYPESET1 222
#define CMD_SET_TYPESET2 223
#define CMD_SET_TYPESET3 224
#define CMD_SET_TYPESET4 225
#define CMD_SET_TYPESET5 226
#define CMD_SET_TYPESET6 227
#define CMD_SET_TYPESET7 228
#define CMD_SET_TYPESET8 229
#define CMD_SET_TYPESET9 230
#define CMD_SET_TYPESET10 231
#define CMD_SET_TYPESET11 232
#define CMD_SET_STATESSET1 233
#define CMD_SET_STATESSET2 234
#define CMD_SET_STATESSET3 235
#define CMD_SET_STATESSET4 236
#define CMD_SET_STATESSET5 237
#define CMD_SET_STATESSET6 238
#define CMD_SET_STATESSET7 239
#define CMD_SET_STATESSET8 240
#define CMD_SET_STATESSET9 241
#define CMD_SET_STATESSET10 242
#define CMD_SET_STATESSET11 243
#define CMD_SET_ASSUME1 244
#define CMD_SET_ASSUME2 245
#define CONTREE
typedef struct cmdNode
{
struct cmdNode *parent, *left, *sib, *rNde;
int index, cmd, action;
char cmdName[100];
}
command_list;
typedef struct conNode
{
struct conNode *left, *leftSib, *rightSib, *anc;
int index;
char label[100];
double length;
}
ConTreeNode;
#if defined (CONTREE)
typedef struct pnode
{
struct pnode *left, *sib, *anc;
int x, y, mark, index;
double length, support, f;
char *label;
unsigned int *partition;
} PolyNode;
#endif
char ChangeCase (char c);
void CleanExit (void);
int DerootSumTree (TreeNode *r);
int Dex(command_list *p);
int Dex3 (ConTreeNode *p);
void DisplayBits (unsigned value);
int DoAction (int actionType);
void ErrorExit (void);
void GetToken (int *tokenType);
void GetUserDownPass (TreeNode *p, TreeNode **x, int *y);
void GetUserHelp (void);
int IsCommandValid (int commdandNumber);
int IsIn (char ch, char s[]);
int IsWhite (char c);
int NucID (char nuc);
int ParseFile (void);
int ParseToken (int tokenType);
void PrepareToken (void);
int ProtID (char aa);
void ReadInTempToken (char tempToken[NUMTOKENCHARS], int i);
int ReadNexusFile (void);
int RealloateTreeParts (void);
int ResID (char nuc);
int RootSumTree (TreeNode *p);
int SetBits (int n);
int ShowTree (TreeNode *r, int isThisTreeRooted);
void SortParts (int *item, int count);
void SortParts2 (int *item, int left, int right);
int StandID (char nuc);
int SummarizeParams (void);
int SummarizeTrees (void);
# if defined (CONTREE)
int FirstTaxonInPartition (unsigned int *partition, int length);
void FlipBits(unsigned int *partition, int length, unsigned int lastMask);
void GetConDownPass (PolyNode **downPass, PolyNode *p, int *i);
int IsPartCompatible (unsigned int *smaller, unsigned int *larger, int length);
int IsPartNested (unsigned int *smaller, unsigned int *larger, int length);
int ShowConTree (FILE *fp, int nNodes, PolyNode *root, int screenWidth);
int ShowConPhylogram (FILE *fp, int nNodes, PolyNode *root, int screenWidth);
void WriteConTree (PolyNode *p, FILE *fp);
# else
void SortCompatParts (int *item, unsigned *item2, double *item3, int count);
void SortCompatParts2 (int *item, unsigned *item2, double *item3, int left, int right);
void WriteConTreeToScreen (ConTreeNode *p, FILE *fp);
# endif
extern int nTaxa, nChar, *origDataMatrix, isNtaxaInitialized, isNcharInitialized, isMatrixAllocated,
dataType, *excludedSites, *sitePartitions, *charType, *charNStates,
molecularClock, *calibrations, *constraints, nConstraints, nCalibrations,
*excludedTaxa, nGen, sampleFreq, printFreq, numChains, isUserTreeDefined, isTreeRooted,
enforceConstraints, enforceCalibrations, inferAncStates, nRateCats, isPartitionDefined, nPartitions,
outgroupNum, saveBrlens, burnIn, consensusType, paramBurn, autoclose, nPerturbations, userBrlensDef,
aaModelType, saveAncFiles, enforceCodonModel, aaCode, inferPoseSel, lagNumber, inferRates, useCovarion,
mcmcBurn, cycleFreq, calcPseudoBf, useParsCriterion;
extern long int randomSeed;
extern char *taxonLabels, subModel[20], baseFreqModel[20], ratesModel[20], clockModel[20], partitionName[50], defPartitionName[50],
tRatioModel[20], revRatesModel[20], nonRevRatesModel[20], shapeModel[20], siteRatesModel[20],
calibrationLabels[32][100], constraintLabels[32][100], outFile[100], qmatprModel[20], basefreqprModel[20],
brlenprModel[20], shapeprModel[20], siterateprModel[20], startingTreeModel[20], sumTreeFile[100], sumParmFile[100],
omegaRatioModel[20], codonModelType[20], omegaprModel[20], lagModel[20], lagprModel[20], covarionModelType[20],
codingType[20], stateFreqPrModel[20];
extern double revRates[6], nonRevRates[12], shape, tRatio, siteRates[50], calibrationTimes[32][2], chainTemp,
qmatprExp, qmatprUni[2], basefreqprDir, brlenprExp, brlenprUni[2], shapeprExp, shapeprUni[2],
siterateprExp, siterateprUni[2], seqErrorProb, speciationRate, extinctionRate, samplingFraction,
omegaRatio, omegaprUni[2], omegaprExp, lagprUni[2], lagprExp,
qMatWinProp, piAlphaProp, rateWinProp, tuningProp, clockTuneProp, timeTuneProp, mTuneProp,
extendPProp, wormTuneProp, bdWinProp, omegaWinProp, rhoWinProp, omegaAlphaProp, invSlideProp,
switchWinProp, alphaWinProp, nodeTimeTuneProp, reconLimProp, tbrExtendPProp, tbrTuneProp, blTuneProp,
statefreqprDir, moveRates[100];
extern TreeNode *userTree, *userTreeRoot;
static int expectedCommands[HIERARCHYSIZE], isInterleaved, *matrixCounter, returnEncountered,
whichTaxon, isFirstInterleavedBlock, lineNumber, generalHelp, globalInt, *charSet, nCharSets,
charSetFrom, charSetTo, charSetWait, charSetFreq, charSetSlashWait, charSetPotWait,
whichPartition, isFirstNode, nextAvailableNode, intNodeNum, transNumber, isSumTreeRooted,
isTranslated, numSumTrees, nUnsignedNeeded, numTreePartsFound, *numFoundOfThisPart, numSumTreesSampled,
foundBrlens, nColumns, headerSize, tempNumColumns, curNumRows, whichRow, whichColumn, numPartsAllocated,
changeToLower, *typeDef, nTypeDefs, charOrdering, *nStatesDef, nNStatesDefs, nCharStates;
static unsigned *treeBits, *treePartsFound, *taxonMask, propSet;
static double *aBrlens, *aOldBrlens, *sBrlens, *paramInfo;
static command_list cmdList[HIERARCHYSIZE], *cmdRoot, *cmdPtr;
static TreeNode *pPtr, *qPtr, *sumTree, *sumTreeRoot, **sumTreeDP;
#if !defined (CONTREE)
static ConTreeNode *constraintTree;
#endif
static char *tokenP, token[STRING_LENGTH], tokenType, inFile[100], *headerNames,
gapChar, matchChar, missingChar, helpRequest[100], charSetLabels[50][100], typeDefLabels[50][100],
nStatesDefLabels[50][100], *transNewNames, *transOldNames;
static char validTokens[NUMCOMMANDS][NUMTOKENCHARS] =
{ "execute", /* 0 */
"begin", /* 1 */
"end", /* 2 */
"mrbayes", /* 3 */
"data", /* 4 */
"trees", /* 5 */
"help", /* 6 */
"quit", /* 7 */
"lset", /* 8 */
"nst", /* 9 */
"basefreq", /* 10 */
"rates", /* 11 */
"dimensions", /* 12 */
"ntax", /* 13 */
"nchar", /* 14 */
"format", /* 15 */
"datatype", /* 16 */
"yes", /* 17 */
"no", /* 18 */
"dna", /* 19 */
"rna", /* 20 */
"protein", /* 21 */
"interleave", /* 22 */
"gap", /* 23 */
"matchchar", /* 24 */
"missing", /* 25 */
"matrix", /* 26 */
"nexus", /* 27 */
"equal", /* 28 */
"gamma", /* 29 */
"sitespec", /* 30 */
"covarion", /* 31 */
"clock", /* 32 */
"unconstrained", /* 33 */
"relaxed", /* 34 */
"strict", /* 35 */
"empirical", /* 36 */
"estimate", /* 37 */
"tratio", /* 38 */
"revmat", /* 39 */
"nonrevmat", /* 40 */
"shape", /* 41 */
"sitepartition", /* 42 */
"siterates", /* 43 */
"partition", /* 44 */
"charset", /* 45 */
"exclude", /* 46 */
"outgroup", /* 47 */
"charstat", /* 48 */
"calibration", /* 49 */
"constraint", /* 50 */
"compchar", /* 51 */
"all", /* 52 */
"include", /* 53 */
"delete", /* 54 */
"restore", /* 55 */
"mcmc", /* 56 */
"seed", /* 57 */
"ngen", /* 58 */
"samplefreq", /* 59 */
"printfreq", /* 60 */
"nchains", /* 61 */
"temp", /* 62 */
"filename", /* 63 */
"prset", /* 64 */
"qmatpr", /* 65 */
"fixed", /* 66 */
"exp", /* 67 */
"uni", /* 68 */
"basefreqpr", /* 69 */
"dir", /* 70 */
"brlenpr", /* 71 */
"bd", /* 72 */
"shapepr", /* 73 */
"siteratepr", /* 74 */
"startingtree", /* 75 */
"random", /* 76 */
"user", /* 77 */
"usertree", /* 78 */
"showtree", /* 79 */
"enforcecal", /* 80 */
"enforcecon", /* 81 */
"inferanc", /* 82 */
"root", /* 83 */
"deroot", /* 84 */
"ncat", /* 85 */
"shownodes", /* 86 */
"savebrlens", /* 87 */
"seqerror", /* 88 */
"sumt", /* 89 */
"sump", /* 90 */
"burnin", /* 91 */
"tree", /* 92 */
"translate", /* 93 */
"contype", /* 94 */
"halfcompat", /* 95 */
"allcompat", /* 96 */
"bayesparams", /* 97 */
"header", /* 98 */
"set", /* 99 */
"autoclose", /* 100 */
"mcmcp", /* 101 */
"nperbs", /* 102 */
"aamodel", /* 103 */
"poisson", /* 104 */
"equalin", /* 105 */
"jones", /* 106 */
"dayhoff", /* 107 */
"gtr", /* 108 */
"omegapr", /* 109 */
"ancfile", /* 110 */
"enforcecodon", /* 111 */
"omegavar", /* 112 */
"ny98", /* 113 */
"omega", /* 114 */
"code", /* 115 */
"universal", /* 116 */
"vertmt", /* 117 */
"mycoplasma", /* 118 */
"yeast", /* 119 */
"ciliates", /* 120 */
"metmt", /* 121 */
"inferpossel", /* 122 */
"adgamma", /* 123 */
"ac1ny98", /* 124 */
"ac2ny98", /* 125 */
"lag", /* 126 */
"lagpr", /* 127 */
"invariant", /* 128 */
"invgamma", /* 129 */
"ssgamma", /* 130 */
"ssadgamma", /* 131 */
"inferrates", /* 132 */
"covny98", /* 133 */
"restriction", /* 134 */
"qmatwin", /* 135 */
"pialpha", /* 136 */
"ratewin", /* 137 */
"tuning", /* 138 */
"clocktune", /* 139 */
"timetune", /* 140 */
"mtune", /* 141 */
"extendp", /* 142 */
"wormtune", /* 143 */
"bdwin", /* 144 */
"omegawin", /* 145 */
"omegaalpha", /* 146 */
"rhowin", /* 147 */
"invslide", /* 148 */
"switchwin", /* 149 */
"alphawin", /* 150 */
"props", /* 151 */
"reconlim", /* 152 */
"covtype", /* 153 */
"ts98", /* 154 */
"gcswitch", /* 155 */
"tbrextendp", /* 156 */
"tbrtune", /* 157 */
"bltune", /* 158 */
"standard", /* 159 */
"mixed", /* 160 */
"coding", /* 161 */
"variable", /* 162 */
"informative", /* 163 */
"noabsence", /* 164 */
"nopresence", /* 165 */
"statefreqpr", /* 166 */
"setmoveprops", /* 167 */
"cyclefreq", /* 168 */
"calcpseudobf", /* 169 */
"parsmodel", /* 170 */
"typeset", /* 171 */
"nstatesset", /* 172 */
"ord", /* 173 */
"unord", /* 174 */
"assume"}; /* 175 */
#if defined(__MWERKS__)
# pragma optimization_level 1
#endif
char ChangeCase (char c)
{
int x;
x = tolower(c);
return (x);
}
void CleanExit (void)
{
if (isMatrixAllocated == YES)
{
free (origDataMatrix);
free (taxonLabels);
free (excludedSites);
free (sitePartitions);
free (matrixCounter);
free (charSet);
free (calibrations);
free (constraints);
free (excludedTaxa);
free (userTree);
free (sumTree);
free (transOldNames);
free (transNewNames);
free (charType);
free (charNStates);
free (typeDef);
free (nStatesDef);
}
nTaxa = nChar = 0;
isMatrixAllocated = NO;
isNtaxaInitialized = NO;
isNcharInitialized = NO;
}
int Dex(command_list *p)
{
if (p == NULL)
return (-1);
else
return (p->index);
}
int Dex2 (TreeNode *p)
{
return (p == NULL) ? -1 : p->index;
}
int Dex3 (ConTreeNode *p)
{
return (p == NULL) ? -1 : p->index;
}
int DerootTree (TreeNode *p)
{
int i, nNodes, isMarked;
double tempBrLen;
TreeNode **downPass, *lft, *m1, *m2, *um1, *um2, *out;
if (isTreeRooted == NO)
{
printf (" ERROR: Tree is already unrooted\n");
return (ERROR);
}
else
nNodes = 2 * nTaxa;
/* bring the outgroup around to the first right position */
downPass = (TreeNode **)malloc((size_t) (2 * nTaxa * sizeof(TreeNode *)));
if (!downPass)
{
printf (" ERROR: Could not allocate downPass\n");
return (ERROR);
}
i = 0;
GetUserDownPass (userTreeRoot, downPass, &i);
isMarked = NO;
for (i=0; i<nNodes; i++)
{
p = downPass[i];
if (p->index == outgroupNum)
{
p->marked = YES;
isMarked = YES;
}
else
p->marked = NO;
}
if (isMarked == NO)
{
printf (" ERROR: Could not find outgroup taxon\n");
return (ERROR);
}
for (i=0; i<nNodes; i++)
{
p = downPass[i];
if (p->left != NULL && p->right != NULL)
if (p->left->marked == YES || p->right->marked == YES)
p->marked = YES;
}
free (downPass);
lft = userTreeRoot->left;
while (lft->left->index != outgroupNum && lft->right->index != outgroupNum)
{
if (lft->left->marked == YES && lft->right->marked == NO)
{
m1 = lft->left;
um1 = lft->right;
if (m1->left != NULL && m1->right != NULL)
{
if (m1->left->marked == YES)
{
m2 = m1->left;
um2 = m1->right;
}
else
{
m2 = m1->right;
um2 = m1->left;
}
lft->left = m2;
lft->right = m1;
m2->anc = lft;
m1->left = um2;
m1->right = um1;
m1->anc = lft;
um1->anc = m1;
um2->anc = m1;
m1->marked = NO;
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
else if (lft->left->marked == NO && lft->right->marked == YES)
{
m1 = lft->right;
um1 = lft->left;
if (m1->left != NULL && m1->right != NULL)
{
if (m1->left->marked == YES)
{
m2 = m1->left;
um2 = m1->right;
}
else
{
m2 = m1->right;
um2 = m1->left;
}
lft->left = m1;
lft->right = m2;
m2->anc = lft;
m1->left = um1;
m1->right = um2;
m1->anc = lft;
um1->anc = m1;
um2->anc = m1;
m1->marked = NO;
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
/* make certain outgroup is to the right of the root */
if (userTreeRoot->left->left->index == outgroupNum)
{
m1 = userTreeRoot->left->left;
m2 = userTreeRoot->left->right;
lft = userTreeRoot->left;
lft->left = m2;
lft->right = m1;
}
/* now, take outgroup and make it point down */
m1 = userTreeRoot;
m2 = userTreeRoot->left;
lft = userTreeRoot->left->left;
out = userTreeRoot->left->right;
tempBrLen = out->length;
if (tempBrLen < 0.0)
tempBrLen = 0.0;
lft->anc = out;
out->left = lft;
out->right = NULL;
out->anc = NULL;
lft->length += tempBrLen;
m1->left = NULL;
m2->left = NULL;
m1->right = NULL;
m2->right = NULL;
m1->anc = NULL;
m2->anc = NULL;
userTreeRoot = out;
isTreeRooted = NO;
/* reindex internal nodes of tree */
i = nTaxa;
FinishTree (userTreeRoot, &i, NO);
return (NO_ERROR);
}
int DerootSumTree (TreeNode *p)
{
int i, nNodes, isMarked;
double tempBrLen;
TreeNode **downPass, *lft, *m1, *m2, *um1, *um2, *out;
if (isSumTreeRooted == NO)
{
printf (" ERROR: Tree is already unrooted\n");
return (ERROR);
}
else
nNodes = 2 * nTaxa;
/* bring the outgroup around to the first right position */
downPass = (TreeNode **)malloc((size_t) (2 * nTaxa * sizeof(TreeNode *)));
if (!downPass)
{
printf (" ERROR: Could not allocate downPass\n");
return (ERROR);
}
i = 0;
GetUserDownPass (sumTreeRoot, downPass, &i);
isMarked = NO;
for (i=0; i<nNodes; i++)
{
p = downPass[i];
if (p->index == outgroupNum)
{
p->marked = YES;
isMarked = YES;
}
else
p->marked = NO;
}
if (isMarked == NO)
{
printf (" ERROR: Could not find outgroup taxon\n");
return (ERROR);
}
for (i=0; i<nNodes; i++)
{
p = downPass[i];
if (p->left != NULL && p->right != NULL)
if (p->left->marked == YES || p->right->marked == YES)
p->marked = YES;
}
free (downPass);
lft = sumTreeRoot->left;
while (lft->left->index != outgroupNum && lft->right->index != outgroupNum)
{
if (lft->left->marked == YES && lft->right->marked == NO)
{
m1 = lft->left;
um1 = lft->right;
if (m1->left != NULL && m1->right != NULL)
{
if (m1->left->marked == YES)
{
m2 = m1->left;
um2 = m1->right;
}
else
{
m2 = m1->right;
um2 = m1->left;
}
lft->left = m2;
lft->right = m1;
m2->anc = lft;
m1->left = um2;
m1->right = um1;
m1->anc = lft;
um1->anc = m1;
um2->anc = m1;
m1->marked = NO;
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
else if (lft->left->marked == NO && lft->right->marked == YES)
{
m1 = lft->right;
um1 = lft->left;
if (m1->left != NULL && m1->right != NULL)
{
if (m1->left->marked == YES)
{
m2 = m1->left;
um2 = m1->right;
}
else
{
m2 = m1->right;
um2 = m1->left;
}
lft->left = m1;
lft->right = m2;
m2->anc = lft;
m1->left = um1;
m1->right = um2;
m1->anc = lft;
um1->anc = m1;
um2->anc = m1;
m1->marked = NO;
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
/* make certain outgroup is to the right of the root */
if (sumTreeRoot->left->left->index == outgroupNum)
{
m1 = sumTreeRoot->left->left;
m2 = sumTreeRoot->left->right;
lft = sumTreeRoot->left;
lft->left = m2;
lft->right = m1;
}
/* now, take outgroup and make it point down */
m1 = sumTreeRoot;
m2 = sumTreeRoot->left;
lft = sumTreeRoot->left->left;
out = sumTreeRoot->left->right;
tempBrLen = out->length;
if (tempBrLen < 0.0)
tempBrLen = 0.0;
lft->anc = out;
out->left = lft;
out->right = NULL;
out->anc = NULL;
lft->length += tempBrLen;
m1->left = NULL;
m2->left = NULL;
m1->right = NULL;
m2->right = NULL;
m1->anc = NULL;
m2->anc = NULL;
sumTreeRoot = out;
isSumTreeRooted = NO;
/* reindex internal nodes of tree */
i = nTaxa;
FinishTree (sumTreeRoot, &i, NO);
return (NO_ERROR);
}
void DisplayBits (unsigned value)
{
int unsignedIntSize;
unsigned c, displayMask;
unsignedIntSize = sizeof (unsigned);
displayMask = 1 << (8*unsignedIntSize-1);
//printf ("%10u = ", value);
for (c=1; c<=8*unsignedIntSize; c++)
{
putchar (value & displayMask ? '1' : '0');
value <<= 1;
if (c % 8 == 0)
putchar (' ');
}
//putchar ('\n');
}
int DoAction (int actionType)
{
int i, j, k, l, nuc, tempInt, tempInt2, foundSet, nNodes, offSet,
foundPartition, allSame, nextConNode, isCompat,
whichIsX, whichIsY, numY[SCREENWIDTH], unsignedIntsize;
unsigned x, y, lastMask;
long int tempLongInt;
double tempD, *tempInfo, a, aOld, s, minX, minY, maxX, maxY,
meanY[SCREENWIDTH];
char tempString[100], tempString2[100], conFile[100];
TreeNode *p;
FILE *fp;
# if defined (CONTREE)
PolyNode *conRoot, *cp, *q, *r, *ql, *pl, *conNodes;
int targetNode, nBits;
double freq;
unsigned int *partition, *ingroupPartition, *outgroupPartition;
# else
ConTreeNode *conRoot, *cp, *cl, *cr, *cn, *cq, **taxaInConstraint, **taxaNotInConstraint;
unsigned *compatParts, *tempParts;
int nTaxaInConstraint, nTaxaNotInConstraint, nCompatParts, nSame1, nSame2, *numOnes;
double *partLengths;
# endif
switch (actionType)
{
case CMD_QUIT:
printf (" Quitting program\n\n");
CleanExit();
exit (0);
break;
case CMD_EXECUTE:
printf (" Executing file named \"%s\"\n", inFile);
if (ReadNexusFile () == ERROR)
{
printf (" Could not execute file\n");
ErrorExit ();
return (ERROR);
}
break;
case CMD_ENTER_INPUT_FILE_NAME1:
changeToLower = NO;
break;
case CMD_ENTER_INPUT_FILE_NAME2:
changeToLower = YES;
strcpy (inFile, token);
strcpy (outFile, inFile);
strcat (outFile, ".out");
strcpy (sumTreeFile, token);
strcat (sumTreeFile, ".out.t");
strcpy (sumParmFile, token);
strcat (sumParmFile, ".out.bp");
break;
case CMD_INIT_NTAX:
sscanf (token, "%d", &tempInt);
nTaxa = tempInt;
isNtaxaInitialized = YES;
break;
case CMD_INIT_NCHAR:
sscanf (token, "%d", &tempInt);
nChar = tempInt;
isNcharInitialized = YES;
break;
case CMD_INIT_DATA_BLOCK:
if (isMatrixAllocated == YES)
{
free (origDataMatrix);
free (taxonLabels);
free (excludedSites);
free (sitePartitions);
free (matrixCounter);
free (charSet);
free (calibrations);
free (constraints);
free (excludedTaxa);
free (userTree);
free (charType);
free (charNStates);
free (typeDef);
free (nStatesDef);
nTaxa = nChar = 0;
}
isMatrixAllocated = NO;
isNtaxaInitialized = NO;
isNcharInitialized = NO;
isUserTreeDefined = NO;
isInterleaved = NO;
gapChar = 0;
matchChar = 0;
missingChar = 0;
dataType = -1;
printf (" Entering data block\n");
break;
case CMD_ALLOC_MATRIX:
if (isMatrixAllocated == NO && isNtaxaInitialized == YES && isNcharInitialized == YES)
{
nCharStates = 4;
origDataMatrix = (int *)malloc((size_t) (nTaxa * nChar * sizeof(int)));
if (!origDataMatrix)
{
printf (" ERROR: Could not allocate origDataMatrix\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nTaxa*nChar; i++)
origDataMatrix[i] = 0;
taxonLabels = (char *)malloc((size_t) (nTaxa * 100 * sizeof(char)));
if (!taxonLabels)
{
printf (" ERROR: Could not allocate taxonLabels\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nTaxa*100; i++)
taxonLabels[i] = ' ';
taxonLabels[nTaxa*100-1] = '\0';
transNewNames = (char *)malloc((size_t) (nTaxa * 100 * sizeof(char)));
if (!transNewNames)
{
printf (" ERROR: Could not allocate transNewNames\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nTaxa*100; i++)
transNewNames[i] = ' ';
transNewNames[nTaxa*100-1] = '\0';
transOldNames = (char *)malloc((size_t) (nTaxa * 100 * sizeof(char)));
if (!transOldNames)
{
printf (" ERROR: Could not allocate transOldNames\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nTaxa*100; i++)
transOldNames[i] = ' ';
transOldNames[nTaxa*100-1] = '\0';
excludedSites = (int *)malloc((size_t) (nChar * sizeof(int)));
if (!excludedSites)
{
printf (" ERROR: Could not allocate excludedSites\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nChar; i++)
excludedSites[i] = NO;
sitePartitions = (int *)malloc((size_t) (nChar * sizeof(int)));
if (!sitePartitions)
{
printf (" ERROR: Could not allocate sitePartitions\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nChar; i++)
sitePartitions[i] = 0;
matrixCounter = (int *)malloc((size_t) (nTaxa * sizeof(int)));
if (!matrixCounter)
{
printf (" ERROR: Could not allocate matrixCounter\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nTaxa; i++)
matrixCounter[i] = 0;
charSet = (int *)malloc((size_t) (nChar * sizeof(int)));
if (!charSet)
{
printf (" ERROR: Could not allocate charSet\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nChar; i++)
charSet[i] = 0;
nCharSets = 0;
typeDef = (int *)malloc((size_t) (nChar * sizeof(int)));
if (!typeDef)
{
printf (" ERROR: Could not allocate typeDef\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nChar; i++)
typeDef[i] = UNORDERED;
nTypeDefs = 0;
nStatesDef = (int *)malloc((size_t) (nChar * sizeof(int)));
if (!nStatesDef)
{
printf (" ERROR: Could not allocate nStatesDef\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nChar; i++)
nStatesDef[i] = 4;
nNStatesDefs = 0;
charType = (int *)malloc((size_t) (nChar * sizeof(int)));
if (!charType)
{
printf (" ERROR: Could not allocate charType\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nChar; i++)
charType[i] = UNORDERED;
charNStates = (int *)malloc((size_t) (nChar * sizeof(int)));
if (!charNStates)
{
printf (" ERROR: Could not allocate charNStates\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nChar; i++)
charNStates[i] = 4;
calibrations = (int *)malloc((size_t) (nTaxa * sizeof(int)));
if (!calibrations)
{
printf (" ERROR: Could not allocate calibrations\n");
ErrorExit ();
return (ERROR);
}
nCalibrations = 0;
for (i=0; i<nTaxa; i++)
calibrations[i] = 0;
constraints = (int *)malloc((size_t) (nTaxa * sizeof(int)));
if (!constraints)
{
printf (" ERROR: Could not allocate constraints\n");
ErrorExit ();
return (ERROR);
}
nConstraints = 0;
for (i=0; i<nTaxa; i++)
constraints[i] = 0;
excludedTaxa = (int *)malloc((size_t) (nTaxa * sizeof(int)));
if (!excludedTaxa)
{
printf (" ERROR: Could not allocate excludedTaxa\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<nTaxa; i++)
excludedTaxa[i] = NO;
userTree = (TreeNode *)malloc((size_t) (2 * nTaxa * sizeof(TreeNode)));
if (!userTree)
{
printf (" ERROR: Could not allocate userTree\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<2*nTaxa; i++)
{
userTree[i].left = NULL;
userTree[i].right = NULL;
userTree[i].anc = NULL;
userTree[i].memoryIndex = i;
userTree[i].index = i;
userTree[i].upDateCl = NO;
userTree[i].length = 0.0;
userTree[i].marked = NO;
strcpy (userTree[i].label, "no name");
strcpy (userTree[i].calibrationName, "no name");
strcpy (userTree[i].constraintName, "no name");
}
sumTree = (TreeNode *)malloc((size_t) (2 * nTaxa * sizeof(TreeNode)));
if (!sumTree)
{
printf (" ERROR: Could not allocate sumTree\n");
ErrorExit ();
return (ERROR);
}
for (i=0; i<2*nTaxa; i++)
{
sumTree[i].left = NULL;
sumTree[i].right = NULL;
sumTree[i].anc = NULL;
sumTree[i].memoryIndex = i;
sumTree[i].index = i;
sumTree[i].upDateCl = NO;
sumTree[i].length = 0.0;
sumTree[i].marked = NO;
strcpy (sumTree[i].label, "no name");
strcpy (sumTree[i].calibrationName, "no name");
strcpy (sumTree[i].constraintName, "no name");
}
isMatrixAllocated = YES;
outgroupNum = 0;
isPartitionDefined = NO;
printf (" Data matrix has %d taxa and %d characters\n", nTaxa, nChar);
}
else
{
printf (" ERROR allocating matrix\n");
ErrorExit ();
return (ERROR);
}
break;
case CMD_INIT_GAPCHAR:
if (strlen(token) == 1)
{
if (dataType == DNA || dataType == RNA)
{
if (NucID (token[0]) != -1)
{
printf (" ERROR: Invalid gap character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
else
{
gapChar = token[0];
printf (" Gaps are coded as %c\n", gapChar);
}
}
else if (dataType == PROTEIN)
{
if (ProtID (token[0]) != -1)
{
printf (" ERROR: Invalid gap character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
else
{
gapChar = token[0];
printf (" Gaps are coded as %c\n", gapChar);
}
}
else if (dataType == RESTRICTION)
{
if (ResID (token[0]) != -1)
{
printf (" ERROR: Invalid gap character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
else
{
gapChar = token[0];
printf (" Gaps are coded as %c\n", gapChar);
}
}
else if (dataType == STANDARD)
{
if (StandID (token[0]) != -1)
{
printf (" ERROR: Invalid gap character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
else
{
gapChar = token[0];
printf (" Gaps are coded as %c\n", gapChar);
}
}
else
{
printf (" ERROR: Undefined data type\n");
ErrorExit ();
return (ERROR);
}
}
else
{
printf (" ERROR: gap character is too long (line %d)\n", lineNumber);
ErrorExit ();
return (ERROR);
}
break;
case CMD_INIT_MATCHCHAR:
if (strlen(token) == 1)
{
if (dataType == DNA || dataType == RNA)
{
if (NucID (token[0]) != -1)
{
printf (" ERROR: Invalid matchchar character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
else
{
matchChar = token[0];
printf (" Matching characters are coded as %c\n", matchChar);
}
}
else if (dataType == PROTEIN)
{
if (ProtID (token[0]) != -1)
{
printf (" ERROR: Invalid matchchar character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
else
{
matchChar = token[0];
printf (" Matching characters are coded as %c\n", matchChar);
}
}
else if (dataType == RESTRICTION)
{
if (ResID (token[0]) != -1)
{
printf (" ERROR: Invalid matchchar character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
else
{
matchChar = token[0];
printf (" Matching characters are coded as %c\n", matchChar);
}
}
else if (dataType == STANDARD)
{
if (StandID (token[0]) != -1)
{
printf (" ERROR: Invalid matchchar character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
else
{
matchChar = token[0];
printf (" Matching characters are coded as %c\n", matchChar);
}
}
else
{
printf (" ERROR: Undefined data type\n");
ErrorExit ();
return (ERROR);
}
}
else
{
printf (" ERROR: matchchar is too long (line %d)\n", lineNumber);
ErrorExit ();
return (ERROR);
}
break;
case CMD_INIT_MISSINGCHAR:
if (strlen(token) == 1)
{
if (dataType == DNA || dataType == RNA)
{
if (NucID (token[0]) != -1)
{
printf (" ERROR: Invalid missingchar character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
}
else if (dataType == PROTEIN)
{
if (ProtID (token[0]) != -1)
{
printf (" ERROR: Invalid missingchar character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
}
else if (dataType == RESTRICTION)
{
if (ResID (token[0]) != -1)
{
printf (" ERROR: Invalid missingchar character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
}
else if (dataType == STANDARD)
{
if (StandID (token[0]) != -1)
{
printf (" ERROR: Invalid missingchar character %c (line %d)\n", token[0], lineNumber);
ErrorExit ();
return (ERROR);
}
}
missingChar = token[0];
printf (" Missing states are coded as %c\n", missingChar);
}
else
{
printf (" ERROR: missing character is too long (line %d)\n", lineNumber);
ErrorExit ();
return (ERROR);
}
break;
case CMD_INIT_INTERLEAVE:
if (token[0] == 'y')
{
isInterleaved = YES;
printf (" Data matrix is interleaved\n");
}
else
{
isInterleaved = NO;
printf (" Data matrix is not interleaved\n");
}
break;
case CMD_INIT_DATATYPE:
if (token[0] == 'd' && token[1] == 'n')
{
dataType = DNA;
nCharStates = 4;
}
else if (token[0] == 'r' && token[1] == 'n')
{
dataType = RNA;
nCharStates = 4;
}
else if (token[0] == 'p' && token[1] == 'r')
{
dataType = PROTEIN;
basefreqprDir = 20.0;
nCharStates = 20;
}
else if (token[0] == 'r' && token[1] == 'e')
{
dataType = RESTRICTION;
strcpy (codingType, "noabsence");
nCharStates = 2;
}
else if (token[0] == 's' && token[1] == 't')
{
dataType = STANDARD;
strcpy (codingType, "variable");
nCharStates = 2;
}
else if (token[0] == 'm' && token[1] == 'i')
{
dataType = MIXED;
}
for (i=0; i<nChar; i++)
{
charNStates[i] = nCharStates;
nStatesDef[i] = nCharStates;
}
printf (" Data matrix contains %s character states\n", token);
break;
case CMD_EXIT_DATA_BLOCK:
printf (" Exiting data block\n");
break;
case CMD_INIT_READ_MATRIX:
for (i=0; i<nTaxa; i++)
matrixCounter[i] = 0;
whichTaxon = 0;
isFirstInterleavedBlock = YES;
break;
case CMD_FILL_MATRIX:
if (isMatrixAllocated == YES)
{
if (returnEncountered == YES)
{
if (whichTaxon >= nTaxa)
{
if (isInterleaved == YES)
whichTaxon = 0;
else
{
printf (" ERROR: Too many taxa (line %d)\n", lineNumber);
ErrorExit ();
return (ERROR);
}
}
if (isFirstInterleavedBlock == YES)
{
i = 0;
while (token[i] != '\0')
{
taxonLabels[whichTaxon*100+i] = token[i];
i++;
}
taxonLabels[whichTaxon*100+i] = '|';
returnEncountered = NO;
whichTaxon++;
taxonLabels[nTaxa*100-1] = '\0';
}
else
{
i = 0;
while (taxonLabels[whichTaxon*100+i] != '|')
{
tempString[i] = taxonLabels[whichTaxon*100+i];
i++;
}
tempString[i] = '\0';
if (!strcmp(tempString, token))
{
printf (" ERROR: Taxon names don't match across interleaved blocks (line %d)\n", lineNumber);
ErrorExit ();
return (ERROR);
}
}
}
else
{
i = 0;
while (token[i] != '\0')
{
if (matrixCounter[whichTaxon-1] == nChar)
{
printf (" ERROR: Too many characters (line %d)\n", lineNumber);
ErrorExit ();
return (ERROR);
}
//printf ("%2d %2d -- %c\n", whichTaxon, matrixCounter[whichTaxon-1], token[i]);
if (token[i] == matchChar)
{
if (whichTaxon - 1 == 0)
{
printf (" ERROR: Matching characters (%c) cannot be in first taxon (line %d)\n",
matchChar, lineNumber);
ErrorExit ();
return (ERROR);
}
origDataMatrix[(whichTaxon-1)*nChar+matrixCounter[whichTaxon-1]] =
origDataMatrix[(0)*nChar+matrixCounter[whichTaxon-1]];
matrixCounter[whichTaxon-1]++;
}
else
{
if (dataType == DNA || dataType == RNA)
nuc = NucID (token[i]);
else if (dataType == PROTEIN)
nuc = ProtID (token[i]);
else if (dataType == RESTRICTION)
nuc = ResID (token[i]);
else if (dataType == STANDARD)
nuc = StandID (token[i]);
else if (dataType == MIXED)
{
nuc = 0;
printf (" ERROR: Unrecognized data type\n");
ErrorExit ();
return (ERROR);
}
else
{
printf (" ERROR: Unrecognized data type\n");
ErrorExit ();
return (ERROR);
}
if (nuc != -1)
{
origDataMatrix[(whichTaxon-1)*nChar+matrixCounter[whichTaxon-1]] = nuc;
matrixCounter[whichTaxon-1]++;
}
else
{
printf (" ERROR: Unrecognized character state %c (line %d)\n", token[i], lineNumber);
ErrorExit ();
return (ERROR);
}
}
i++;
}
}
}
else
{
printf (" ERROR: Cannot read in matrix because it is not allocated\n");
}
break;
case CMD_FINISH_READ_MATRIX:
for (i=0; i<nTaxa-1; i++)
{
for (j=i+1; j<nTaxa; j++)
{
k = 0;
while (taxonLabels[i*100+k] != '|')
{
tempString[k] = taxonLabels[i*100+k];
k++;
}
tempString[k] = '\0';
k = 0;
while (taxonLabels[j*100+k] != '|')
{
tempString2[k] = taxonLabels[j*100+k];
k++;
}
tempString2[k] = '\0';
if (!strcmp(tempString, tempString2))
{
printf ("\n ERROR: Taxa %d and %d have the same name. The taxon names\n", i+1, j+1);
printf (" must all be different.\n\n");
ErrorExit ();
return (ERROR);
}
}
}
tempInt = NO;
for (i=0; i<nTaxa; i++)
{
if (matrixCounter[i] != nChar)
{
printf (" ERROR: Too few characters for taxon %d\n", i+1);
tempInt = YES;
}
}
if (whichTaxon != nTaxa)
{
printf (" ERROR: Too few taxa in matrix (expecting %d taxa)\n", nTaxa);
tempInt = YES;
}
if (tempInt == YES)
{
ErrorExit ();
return (ERROR);
}
else
printf (" Matrix successfully read\n");
# if 0
{
int j;
for (j=0; j<nTaxa; j++)
{
printf (" ");
i = 0;
while (taxonLabels[j*100+i] != '|')
{
printf ("%c", taxonLabels[j*100+i]);
i++;
}
printf (" -> ");
for (i=0; i<nChar; i++)
printf ("%2d ", origDataMatrix[j*nChar+i]);
printf ("\n");
}
}
# endif
break;
case CMD_ENTER_HELP_Q:
generalHelp = NO;
strcpy (helpRequest, token);
break;
case CMD_GET_USER_SOME_HELP:
GetUserHelp ();
break;
case CMD_INIT_HELP:
generalHelp = YES;
break;
case CMD_SET_NST:
sscanf (token, "%d", &tempInt);
if (tempInt == 1 || tempInt == 2 || tempInt == 6 || tempInt == 12)
{
printf (" Setting nst=%d\n", tempInt);
strcpy (subModel, token);
}
else
printf (" ERROR: Invalid number of substitution parameters\n");
break;
case CMD_SET_RATES:
strcpy (ratesModel, token);
printf (" Setting rates=%s\n", token);
break;
case CMD_SET_BASE_FREQ:
strcpy (baseFreqModel, token);
printf (" Setting basefreq=%s\n", token);
break;
case CMD_SET_CLOCK:
strcpy (clockModel, token);
printf (" Setting clock=%s\n", token);
break;
case CMD_END_NST:
break;
case CMD_INIT_TRATIO:
if (token[0] == 'e')
{
strcpy(tRatioModel, token);
tRatio = 1.0;
}
else
{
strcpy (tRatioModel, "user defined");
sscanf (token, "%lf", &tempD);
tRatio = tempD;
}
printf (" Setting tratio = %lf\n", tRatio);
break;
case CMD_INIT_REVRATES:
if (token[0] == 'e')
{
strcpy(revRatesModel, token);
tRatio = 1.0;
}
else
{
globalInt = 0;
strcpy (revRatesModel, "user defined");
}
printf (" Setting rates of reversible model\n", tRatio);
break;
case CMD_INIT_REVRATES2:
if (globalInt > 5)
{
printf (" ERROR: Too many user rates assigned\n");
return (ERROR);
}
else
{
sscanf (token, "%lf", &tempD);
revRates[globalInt++] = tempD;
}
break;
case CMD_INIT_REVRATES3:
if (globalInt != 6)
{
printf (" ERROR: Incorrect number of rates assigned\n");
return (ERROR);
}
else
{
for (i=0; i<5; i++)
revRates[i] /= revRates[5];
revRates[5] = 1.0;
}
break;
case CMD_INIT_NONREVRATES:
if (token[0] == 'e')
{
strcpy(nonRevRatesModel, token);
tRatio = 1.0;
}
else
{
globalInt = 0;
strcpy (nonRevRatesModel, "user defined");
}
printf (" Setting rates of non-reversible model\n", tRatio);
break;
case CMD_INIT_NONREVRATES2:
if (globalInt > 11)
{
printf (" ERROR: Too many user rates assigned\n");
return (ERROR);
}
else
{
sscanf (token, "%lf", &tempD);
nonRevRates[globalInt++] = tempD;
}
break;
case CMD_INIT_NONREVRATES3:
if (globalInt != 12)
{
printf (" ERROR: Incorrect number of rates assigned\n");
return (ERROR);
}
else
{
for (i=0; i<11; i++)
nonRevRates[i] /= nonRevRates[11];
nonRevRates[11] = 1.0;
}
break;
case CMD_INIT_SHAPE:
if (token[0] == 'e')
{
strcpy(shapeModel, token);
shape = 0.5;
}
else
{
sscanf (token, "%lf", &tempD);
shape = tempD;
strcpy (shapeModel, "user defined");
}
printf (" Setting gamma shape parameter = %lf\n", shape);
break;
case CMD_INIT_PARTITION:
strcpy(partitionName, token);
break;
case CMD_INIT_SITERATES:
if (token[0] == 'e')
{
strcpy(siteRatesModel, token);
}
else
{
globalInt = 0;
strcpy (siteRatesModel, "user defined");
}
printf (" Setting rates for partitions\n");
break;
case CMD_INIT_SITERATES2:
if (globalInt > 49)
{
printf (" ERROR: Too many site rates assigned\n");
return (ERROR);
}
else
{
sscanf (token, "%lf", &tempD);
siteRates[globalInt++] = tempD;
}
break;
case CMD_INIT_CHARSET_NAME:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
i = 0;
while (token[i] != '\0')
{
charSetLabels[nCharSets][i] = token[i];
i++;
}
charSetLabels[nCharSets][i] = '|';
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetPotWait = YES;
charSetFreq = 1;
printf (" Assigning character set \"");
i = 0;
while (charSetLabels[nCharSets][i] != '|')
{
printf ("%c", charSetLabels[nCharSets][i]);
i++;
}
printf ("\"\n");
nCharSets++;
break;
case CMD_INIT_CHARSET_NAME2:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
printf (" ERROR: You cannot use charset names that are digits\n");
return (ERROR);
break;
case CMD_INIT_CHARSET:
if (token[0] == '-')
{
charSetWait = YES;
charSetPotWait = YES;
}
else if (token[0] == '\\')
{
charSetSlashWait = YES;
charSetPotWait = YES;
}
else
{
if (charSetWait == NO && charSetSlashWait == NO && charSetPotWait == NO)
{
j = charSetFreq;
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
if (j % charSetFreq == 0)
charSet[i] += (int)pow(2.0, (double)nCharSets);
j++;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetFreq = 1;
charSetPotWait = YES;
}
sscanf (token, "%d", &tempInt);
if (charSetSlashWait == YES && charSetWait == YES)
{
printf (" ERROR: Problem assigning character set\n");
return (ERROR);
}
if (charSetSlashWait == YES)
{
charSetFreq = tempInt;
charSetSlashWait = NO;
charSetPotWait = NO;
}
else if (charSetWait == YES)
{
charSetTo = tempInt;
charSetWait = NO;
charSetPotWait = NO;
}
else
{
if (charSetWait == NO)
{
charSetFrom = tempInt;
charSetTo = tempInt;
charSetPotWait = NO;
}
else
{
charSetTo = tempInt;
charSetPotWait = NO;
}
}
}
break;
case CMD_INIT_CHARSET2:
if (charSetWait == NO && charSetSlashWait == NO && charSetPotWait == NO)
{
j = charSetFreq;
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
if (j % charSetFreq == 0)
charSet[i] += (int)pow(2.0, (double)nCharSets);
j++;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetFreq = 1;
charSetPotWait = YES;
}
# if 0
for (i=0; i<nChar; i++)
printf ("%d ", charSet[i]);
printf("\n");
# endif
break;
case CMD_ENTER_MRBAYES_BLOCK:
printf (" Entering MrBayes block\n");
break;
case CMD_EXIT_MRBAYES_BLOCK:
printf (" Exiting MrBayes block\n");
break;
case CMD_INIT_EXCLUDE:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetPotWait = YES;
printf (" Excluding characters ");
break;
case CMD_EXCLUDE:
if (token[0] == '-')
{
charSetWait = YES;
charSetPotWait = YES;
printf ("to ");
}
else
{
if (charSetWait == NO && charSetPotWait == NO)
{
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
excludedSites[i] = YES;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetPotWait = YES;
}
sscanf (token, "%d", &tempInt);
printf ("%d ", tempInt);
if (charSetWait == YES)
{
charSetTo = tempInt;
charSetWait = NO;
charSetPotWait = NO;
}
else
{
if (charSetWait == NO)
{
charSetFrom = tempInt;
charSetTo = tempInt;
charSetPotWait = NO;
}
else
{
charSetTo = tempInt;
charSetPotWait = NO;
}
}
}
break;
case CMD_EXCLUDE2:
foundSet = NO;
for (i=0; i<nCharSets; i++)
{
j = 0;
while (charSetLabels[i][j] != '|')
{
tempString[j] = charSetLabels[i][j];
j++;
}
tempString[j] = '\0';
if (!strcmp(tempString, token))
{
printf ("in character set \"%s\" ", token);
foundSet = YES;
//printf ("match at %s %s\n", token, tempString);
tempInt = (int)pow(2.0, (double)(i+1));
for (j=0; j<nChar; j++)
{
tempInt2 = tempInt & charSet[j];
if (tempInt == tempInt2)
{
excludedSites[j] = YES;
}
}
}
}
if (foundSet == NO)
{
printf ("\n ERROR: Could not find character set %s\n", token);
return (ERROR);
}
break;
case CMD_EXCLUDE3:
if (charSetWait == NO && charSetPotWait == NO)
{
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
if (excludedSites[i] == YES)
printf ("\n WARNING: Site %d already excluded\n", i+1);
else
excludedSites[i] = YES;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetPotWait = YES;
}
printf ("\n");
# if 0
for (i=0; i<nChar; i++)
printf ("%d", excludedSites[i]);
printf ("\n");
# endif
break;
case CMD_EXCLUDE4:
for (i=0; i<nChar; i++)
{
excludedSites[i] = YES;
}
break;
case CMD_DEF_PARTITION:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
strcpy (defPartitionName, token);
printf (" Defining partition called \"%s\"\n", defPartitionName);
break;
case CMD_PARTITION:
printf (" ERROR: Cannot use digit for partition name\n");
return (ERROR);
break;
case CMD_PARTITION2:
sscanf (token, "%d", &tempInt);
nPartitions = tempInt;
printf (" Number of partitions = %d\n", nPartitions);
whichPartition = 0;
break;
case CMD_PARTITION3:
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetPotWait = YES;
charSetFreq = 1;
whichPartition++;
if (whichPartition > nPartitions)
{
printf (" ERROR: You exceeded the %d partitions you specified.\n", nPartitions);
return (ERROR);
}
break;
case CMD_PARTITION4:
if (token[0] == '-')
{
charSetWait = YES;
charSetPotWait = YES;
}
else if (token[0] == '\\')
{
charSetSlashWait = YES;
charSetPotWait = YES;
}
else
{
if (charSetWait == NO && charSetSlashWait == NO && charSetPotWait == NO)
{
j = charSetFreq;
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
if (j % charSetFreq == 0)
sitePartitions[i] = whichPartition;
j++;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetFreq = 1;
charSetPotWait = YES;
}
sscanf (token, "%d", &tempInt);
if (charSetSlashWait == YES && charSetWait == YES)
{
printf (" ERROR: Problem assigning character set\n");
return (ERROR);
}
if (charSetSlashWait == YES)
{
charSetFreq = tempInt;
charSetSlashWait = NO;
charSetPotWait = NO;
}
else if (charSetWait == YES)
{
charSetTo = tempInt;
charSetWait = NO;
charSetPotWait = NO;
}
else
{
if (charSetWait == NO)
{
charSetFrom = tempInt;
charSetTo = tempInt;
charSetPotWait = NO;
}
else
{
charSetTo = tempInt;
charSetPotWait = NO;
}
}
}
break;
case CMD_PARTITION5:
if (charSetWait == NO && charSetSlashWait == NO && charSetPotWait == NO)
{
j = charSetFreq;
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
if (j % charSetFreq == 0)
sitePartitions[i] = whichPartition;
j++;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetFreq = 1;
charSetPotWait = YES;
}
if (token[0] == ';')
{
if (whichPartition != nPartitions)
{
printf (" ERROR: An incorrect number of partitions are defined.\n", nPartitions);
return (ERROR);
}
isPartitionDefined = YES;
}
if (token[0] == ',')
{
whichPartition++;
if (whichPartition > nPartitions)
{
printf (" ERROR: You exceeded the %d partitions you specified.\n", nPartitions);
return (ERROR);
}
}
else
{
for (i=0; i<nChar; i++)
{
if (excludedSites[i] == NO && sitePartitions[i] == 0)
{
printf (" ERROR: Site %d is not assigned to a partition\n", i+1);
return (ERROR);
}
}
}
# if 0
for (i=0; i<nChar; i++)
printf ("%d ", sitePartitions[i]);
printf("\n");
# endif
break;
case CMD_PARTITION6:
foundSet = NO;
for (i=0; i<nCharSets; i++)
{
j = 0;
while (charSetLabels[i][j] != '|')
{
tempString[j] = charSetLabels[i][j];
j++;
}
tempString[j] = '\0';
if (!strcmp(tempString, token))
{
foundSet = YES;
//printf ("match at %s %s\n", token, tempString);
tempInt = (int)pow(2.0, (double)(i+1));
for (j=0; j<nChar; j++)
{
tempInt2 = tempInt & charSet[j];
if (tempInt == tempInt2)
{
sitePartitions[j] = whichPartition;
}
}
}
}
if (foundSet == NO)
{
printf (" ERROR: Could not find charset %s\n", token);
return (ERROR);
}
break;
case CMD_DEF_OUTGROUP1:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
tempInt = NO;
for (j=0; j<nTaxa; j++)
{
i = 0;
while (taxonLabels[j*100+i] != '|')
{
tempString[i] = taxonLabels[j*100+i];
i++;
}
tempString[i] = '\0';
if (!strcmp(tempString, token))
{
tempInt = YES;
break;
}
}
if (tempInt == YES)
{
outgroupNum = j;
printf (" Setting outgroup to species %s\n", tempString);
}
else
{
printf (" ERROR: Taxon name \"%s\" is not found\n", token);
return (ERROR);
}
if (isUserTreeDefined == YES)
{
if (isTreeRooted == YES)
{
if (DerootTree (userTreeRoot) == ERROR)
return (ERROR);
if (RootTree (userTreeRoot) == ERROR)
return (ERROR);
}
else
{
if (RootTree (userTreeRoot) == ERROR)
return (ERROR);
if (DerootTree (userTreeRoot) == ERROR)
return (ERROR);
}
}
break;
case CMD_DEF_OUTGROUP2:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
sscanf (token, "%d", &tempInt);
if (tempInt <= 0 || tempInt > nTaxa)
{
printf (" ERROR: Outgroup number out of range\n");
return (ERROR);
}
else
{
tempInt--;
outgroupNum = tempInt;
printf (" Setting outgroup to species \"");
i = 0;
while (taxonLabels[outgroupNum*100+i] != '|')
{
printf ("%c", taxonLabels[outgroupNum*100+i]);
i++;
}
printf ("\"\n");
}
if (isUserTreeDefined == YES)
{
if (isTreeRooted == YES)
{
if (DerootTree (userTreeRoot) == ERROR)
return (ERROR);
if (RootTree (userTreeRoot) == ERROR)
return (ERROR);
}
else
{
if (RootTree (userTreeRoot) == ERROR)
return (ERROR);
if (DerootTree (userTreeRoot) == ERROR)
return (ERROR);
}
}
break;
case CMD_SHOW_CHAR_STAT:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
printf (" site included/excluded partition number\n");
printf (" ------------------------------------------------\n");
for (i=0; i<nChar; i++)
{
printf ("%5d ", i+1);
if (excludedSites[i] == YES)
printf (" excluded ");
else
printf (" included ");
if (isPartitionDefined == YES)
printf (" %5d ", sitePartitions[i]);
else
printf (" no partition");
if (charType[i] == ORDERED)
printf (" ord ");
else
printf (" unord ");
printf (" %2d ", charNStates[i]);
printf ("\n");
}
break;
case CMD_CALIBRATION1:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (nCalibrations >= 31)
{
printf (" ERROR: Too many calibrations (32 maximum)\n");
return (ERROR);
}
printf (" Reading calibration \"%s\"\n", token);
i = 0;
while (token[i] != '\0')
{
calibrationLabels[nCalibrations][i] = token[i];
i++;
}
calibrationLabels[nCalibrations][i] = '|';
break;
case CMD_CALIBRATION2:
printf (" ERROR: Calibration label cannot be a number\n");
break;
case CMD_CALIBRATION3:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (nCalibrations >= 31)
{
printf (" ERROR: Too many calibrations (32 maximum)\n");
return (ERROR);
}
sscanf (token, "%lf", &tempD);
calibrationTimes[nCalibrations][0] = tempD;
break;
case CMD_CALIBRATION4:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (nCalibrations >= 31)
{
printf (" ERROR: Too many calibrations (32 maximum)\n");
return (ERROR);
}
sscanf (token, "%lf", &tempD);
calibrationTimes[nCalibrations][1] = tempD;
break;
case CMD_CALIBRATION5:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (nCalibrations >= 31)
{
printf (" ERROR: Too many calibrations (32 maximum)\n");
return (ERROR);
}
tempInt = NO;
for (j=0; j<nTaxa; j++)
{
i = 0;
while (taxonLabels[j*100+i] != '|')
{
tempString[i] = taxonLabels[j*100+i];
i++;
}
tempString[i] = '\0';
if (!strcmp(tempString, token))
{
tempInt = YES;
break;
}
}
if (tempInt == YES)
{
calibrations[j] += (int)pow(2.0, (double)(nCalibrations));
}
else
{
printf (" ERROR: Taxon name \"%s\" is not found\n", token);
return (ERROR);
}
break;
case CMD_CALIBRATION6:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (nCalibrations >= 31)
{
printf (" ERROR: Too many calibrations (32 maximum)\n");
return (ERROR);
}
sscanf (token, "%d", &tempInt);
tempInt--;
if (tempInt < 0 || tempInt >= nTaxa)
{
printf (" ERROR: Taxon number is out of range\n");
}
else
{
calibrations[tempInt] += (int)pow(2.0, (double)(nCalibrations));
}
break;
case CMD_CALIBRATION7:
# if 0
i = 0;
while (calibrationLabels[nCalibrations][i] != '|')
{
printf ("%c", calibrationLabels[nCalibrations][i]);
i++;
}
printf (" (%lf %lf) -> ", calibrationTimes[nCalibrations][0], calibrationTimes[nCalibrations][1]);
for (i=0; i<nTaxa; i++)
printf ("%2d ", calibrations[i]);
printf ("\n");
# endif
nCalibrations++;
break;
case CMD_CONSTRAINT1:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (nConstraints >= 31)
{
printf (" ERROR: Too many constraints (32 maximum)\n");
return (ERROR);
}
printf (" Reading constraint \"%s\"\n", token);
i = 0;
while (token[i] != '\0')
{
constraintLabels[nConstraints][i] = token[i];
i++;
}
constraintLabels[nConstraints][i] = '|';
break;
case CMD_CONSTRAINT2:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (nConstraints >= 31)
{
printf (" ERROR: Too many constraints (32 maximum)\n");
return (ERROR);
}
printf (" ERROR: Constraint label cannot be a number\n");
break;
case CMD_CONSTRAINT3:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (nConstraints >= 31)
{
printf (" ERROR: Too many constraints (32 maximum)\n");
return (ERROR);
}
tempInt = NO;
for (j=0; j<nTaxa; j++)
{
i = 0;
while (taxonLabels[j*100+i] != '|')
{
tempString[i] = taxonLabels[j*100+i];
i++;
}
tempString[i] = '\0';
if (!strcmp(tempString, token))
{
tempInt = YES;
break;
}
}
if (tempInt == YES)
{
constraints[j] += (int)pow(2.0, (double)(nConstraints));
}
else
{
printf (" ERROR: Taxon name \"%s\" is not found\n", token);
return (ERROR);
}
break;
case CMD_CONSTRAINT4:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (nConstraints >= 31)
{
printf (" ERROR: Too many constraints (32 maximum)\n");
return (ERROR);
}
sscanf (token, "%d", &tempInt);
tempInt--;
if (tempInt < 0 || tempInt >= nTaxa)
{
printf (" ERROR: Taxon number is out of range\n");
}
else
{
constraints[tempInt] += (int)pow(2.0, (double)(nConstraints));
}
break;
case CMD_CONSTRAINT5:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (nConstraints >= 31)
{
printf (" ERROR: Too many constraints (32 maximum)\n");
return (ERROR);
}
# if 0
i = 0;
while (constraintLabels[nConstraints][i] != '|')
{
printf ("%c", constraintLabels[nConstraints][i]);
i++;
}
printf (" -> ");
for (i=0; i<nTaxa; i++)
printf ("%2d ", constraints[i]);
printf ("\n");
# endif
nConstraints++;
break;
case CMD_INIT_INCLUDE:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetPotWait = YES;
printf (" Including characters ");
break;
case CMD_INCLUDE:
if (token[0] == '-')
{
charSetWait = YES;
charSetPotWait = YES;
printf ("to ");
}
else
{
if (charSetWait == NO && charSetPotWait == NO)
{
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
excludedSites[i] = NO;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetPotWait = YES;
}
sscanf (token, "%d", &tempInt);
printf ("%d ", tempInt);
if (charSetWait == YES)
{
charSetTo = tempInt;
charSetWait = NO;
charSetPotWait = NO;
}
else
{
if (charSetWait == NO)
{
charSetFrom = tempInt;
charSetTo = tempInt;
charSetPotWait = NO;
}
else
{
charSetTo = tempInt;
charSetPotWait = NO;
}
}
}
break;
case CMD_INCLUDE2:
for (i=0; i<nCharSets; i++)
{
j = 0;
while (charSetLabels[i][j] != '|')
{
tempString[j] = charSetLabels[i][j];
j++;
}
tempString[j] = '\0';
if (!strcmp(tempString, token))
{
printf ("in character set \"%s\" ", token);
//printf ("match at %s %s\n", token, tempString);
tempInt = (int)pow(2.0, (double)(i+1));
for (j=0; j<nChar; j++)
{
tempInt2 = tempInt & charSet[j];
if (tempInt == tempInt2)
{
excludedSites[j] = NO;
}
}
}
}
break;
case CMD_INCLUDE3:
if (charSetWait == NO && charSetPotWait == NO)
{
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
excludedSites[i] = NO;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetPotWait = YES;
}
printf ("\n");
# if 0
for (i=0; i<nChar; i++)
printf ("%d", excludedSites[i]);
printf ("\n");
# endif
break;
case CMD_INCLUDE4:
for (i=0; i<nChar; i++)
{
excludedSites[i] = NO;
}
break;
case CMD_DELETE1:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
tempInt = NO;
for (j=0; j<nTaxa; j++)
{
i = 0;
while (taxonLabels[j*100+i] != '|')
{
tempString[i] = taxonLabels[j*100+i];
i++;
}
tempString[i] = '\0';
if (!strcmp(tempString, token))
{
tempInt = YES;
break;
}
}
if (tempInt == YES)
{
excludedTaxa[j] = YES;
printf (" Excluded taxon %s\n", token);
}
else
{
printf (" ERROR: Taxon name \"%s\" is not found\n", token);
return (ERROR);
}
break;
case CMD_DELETE2:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
sscanf (token, "%d", &tempInt);
tempInt--;
if (tempInt < 0 || tempInt >= nTaxa)
{
printf (" ERROR: Taxon number is out of range\n");
}
else
{
excludedTaxa[tempInt] = YES;
printf (" Excluded taxon ");
i = 0;
while (taxonLabels[tempInt*100+i] != '|')
{
printf ("%c", taxonLabels[tempInt*100+i]);
i++;
}
printf ("\n");
}
break;
case CMD_DELETE3:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
printf (" Excluded all taxa\n", token);
for (i=0; i<nTaxa; i++)
excludedTaxa[i] = YES;
break;
case CMD_RESTORE1:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
tempInt = NO;
for (j=0; j<nTaxa; j++)
{
i = 0;
while (taxonLabels[j*100+i] != '|')
{
tempString[i] = taxonLabels[j*100+i];
i++;
}
tempString[i] = '\0';
if (!strcmp(tempString, token))
{
tempInt = YES;
break;
}
}
if (tempInt == YES)
{
excludedTaxa[j] = NO;
printf (" Included taxon %s\n", token);
}
else
{
printf (" ERROR: Taxon name \"%s\" is not found\n", token);
return (ERROR);
}
break;
case CMD_RESTORE2:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
sscanf (token, "%d", &tempInt);
tempInt--;
if (tempInt < 0 || tempInt >= nTaxa)
{
printf (" ERROR: Taxon number is out of range\n");
}
else
{
excludedTaxa[tempInt] = NO;
printf (" Included taxon ");
i = 0;
while (taxonLabels[tempInt*100+i] != '|')
{
printf ("%c", taxonLabels[tempInt*100+i]);
i++;
}
printf ("\n");
}
break;
case CMD_RESTORE3:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
printf (" Included all taxa\n", token);
for (i=0; i<nTaxa; i++)
excludedTaxa[i] = NO;
break;
case CMD_MCMC:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
break;
case CMD_MCMC1:
sscanf (token, "%ld", &tempLongInt);
randomSeed = tempLongInt;
break;
case CMD_MCMC2:
sscanf (token, "%d", &tempInt);
nGen = tempInt;
break;
case CMD_MCMC3:
sscanf (token, "%d", &tempInt);
sampleFreq = tempInt;
break;
case CMD_MCMC4:
sscanf (token, "%d", &tempInt);
printFreq = tempInt;
break;
case CMD_MCMC5:
sscanf (token, "%d", &tempInt);
numChains = tempInt;
break;
case CMD_MCMC6:
sscanf (token, "%lf", &tempD);
chainTemp = tempD;
break;
case CMD_MCMC7:
strcpy (outFile, token);
break;
case CMD_MCMC8:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (RunChain () == ERROR)
return (ERROR);
break;
case CMD_MCMC9:
if (token[0] == 'r')
strcpy (startingTreeModel, "random");
else
strcpy (startingTreeModel, "user");
break;
case CMD_PRIOR1:
strcpy (qmatprModel, "fixed");
printf (" Fixing prior for Q matrix\n");
break;
case CMD_PRIOR2:
strcpy (qmatprModel, "exponential");
printf (" Exponential prior for Q matrix\n");
break;
case CMD_PRIOR3:
strcpy (qmatprModel, "uniform");
printf (" Uniform prior for Q matrix\n");
break;
case CMD_PRIOR4:
sscanf (token, "%lf", &tempD);
if (tempD <= 0.0)
{
printf (" ERROR: Exponential parameter must be positive\n");
return (ERROR);
}
qmatprExp = tempD;
break;
case CMD_PRIOR5:
sscanf (token, "%lf", &tempD);
if (tempD < 0.0)
{
printf (" ERROR: Lower bound on uniform must be positive\n");
return (ERROR);
}
qmatprUni[0] = tempD;
break;
case CMD_PRIOR6:
sscanf (token, "%lf", &tempD);
if (tempD <= qmatprUni[0])
{
printf (" ERROR: Upper bound on uniform must be greater than lower bound\n");
return (ERROR);
}
qmatprUni[1] = tempD;
break;
case CMD_PRIOR7:
strcpy (basefreqprModel, "fixed");
printf (" Fixing prior for base frequencies\n");
break;
case CMD_PRIOR8:
strcpy (basefreqprModel, "dirichlet");
printf (" Dirichlet prior for base frequencies\n");
break;
case CMD_PRIOR9:
sscanf (token, "%lf", &tempD);
if (tempD <= 0.0)
{
printf (" ERROR: Dirichlet parameter must be positive\n");
return (ERROR);
}
basefreqprDir = tempD;
break;
case CMD_PRIOR10:
strcpy (brlenprModel, "uniform");
printf (" Uniform prior on branch lengths\n");
break;
case CMD_PRIOR11:
strcpy (brlenprModel, "exponential");
printf (" Exponential prior on branch lengths\n");
break;
case CMD_PRIOR12:
strcpy (brlenprModel, "birth-death");
printf (" Birth-death prior on branch lengths\n");
break;
case CMD_PRIOR13:
sscanf (token, "%lf", &tempD);
if (tempD < 0.0)
{
printf (" ERROR: Lower bound on uniform must be positive\n");
return (ERROR);
}
brlenprUni[0] = tempD;
break;
case CMD_PRIOR14:
sscanf (token, "%lf", &tempD);
if (tempD <= brlenprUni[0])
{
printf (" ERROR: Upper bound on uniform must be greater than lower bound\n");
return (ERROR);
}
brlenprUni[1] = tempD;
break;
case CMD_PRIOR15:
sscanf (token, "%lf", &tempD);
if (tempD <= 0.0)
{
printf (" ERROR: Exponential parameter must be positive\n");
return (ERROR);
}
brlenprExp = tempD;
break;
case CMD_PRIOR16:
strcpy (shapeprModel, "fixed");
printf (" Fixing gamma shape parameter\n");
break;
case CMD_PRIOR17:
strcpy (shapeprModel, "uniform");
printf (" Uniform prior on shape parameter\n");
break;
case CMD_PRIOR18:
strcpy (shapeprModel, "exponential");
printf (" Exponential prior on shape parameter\n");
break;
case CMD_PRIOR19:
sscanf (token, "%lf", &tempD);
if (tempD < 0.0)
{
printf (" ERROR: Lower bound on uniform must be positive\n");
return (ERROR);
}
shapeprUni[0] = tempD;
break;
case CMD_PRIOR20:
sscanf (token, "%lf", &tempD);
if (tempD <= shapeprUni[0])
{
printf (" ERROR: Upper bound on uniform must be greater than lower bound\n");
return (ERROR);
}
shapeprUni[1] = tempD;
break;
case CMD_PRIOR21:
sscanf (token, "%lf", &tempD);
if (tempD <= 0.0)
{
printf (" ERROR: Exponential parameter must be positive\n");
return (ERROR);
}
shapeprExp = tempD;
break;
case CMD_PRIOR22:
strcpy (siterateprModel, "fixed");
printf (" Fixing site rates\n");
break;
case CMD_PRIOR23:
strcpy (siterateprModel, "uniform");
printf (" Uniform prior on site rates\n");
break;
case CMD_PRIOR24:
strcpy (siterateprModel, "exponential");
printf (" Exponential prior on site rates\n");
break;
case CMD_PRIOR25:
sscanf (token, "%lf", &tempD);
if (tempD < 0.0)
{
printf (" ERROR: Lower bound on uniform must be positive\n");
return (ERROR);
}
siterateprUni[0] = tempD;
break;
case CMD_PRIOR26:
sscanf (token, "%lf", &tempD);
if (tempD <= siterateprUni[0])
{
printf (" ERROR: Upper bound on uniform must be greater than lower bound\n");
return (ERROR);
}
siterateprUni[1] = tempD;
break;
case CMD_PRIOR27:
sscanf (token, "%lf", &tempD);
if (tempD <= 0.0)
{
printf (" ERROR: Exponential parameter must be positive\n");
return (ERROR);
}
siterateprExp = tempD;
break;
case CMD_TREE:
/* = */
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
if (isUserTreeDefined == YES)
{
printf (" ERROR: User tree already defined\n");
return (ERROR);
}
isFirstNode = YES;
pPtr = qPtr = &userTree[0];
nextAvailableNode = 0;
userBrlensDef = NO;
break;
case CMD_TREE1:
/* ( */
if (isFirstNode == YES)
{
pPtr = &userTree[nextAvailableNode];
nextAvailableNode++;
isFirstNode = NO;
userTreeRoot = pPtr;
}
else
{
if (nextAvailableNode+1 >= 2*nTaxa)
{
printf (" ERROR: Too many nodes in tree\n");
return (ERROR);
}
if (pPtr->left == NULL)
{
pPtr = &userTree[nextAvailableNode];
nextAvailableNode++;
qPtr->left = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->right == NULL)
{
pPtr = &userTree[nextAvailableNode];
nextAvailableNode++;
qPtr->right = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->anc == NULL)
{
pPtr = &userTree[nextAvailableNode];
nextAvailableNode++;
qPtr->anc = pPtr;
pPtr->left = qPtr;
qPtr = pPtr;
userTreeRoot = pPtr;
pPtr->marked = YES;
}
else
{
printf ("\n ERROR: Tree is not bifurcating\n");
return (ERROR);
}
}
break;
case CMD_TREE2:
/* <name> */
if (nextAvailableNode+1 >= 2*nTaxa)
{
printf ("\n ERROR: Too many nodes in tree\n");
return (ERROR);
}
tempInt = NO;
for (j=0; j<nTaxa; j++)
{
i = 0;
while (taxonLabels[j*100+i] != '|')
{
tempString[i] = taxonLabels[j*100+i];
i++;
}
tempString[i] = '\0';
if (!strcmp(tempString, token))
{
tempInt = YES;
break;
}
}
if (tempInt == YES)
{
if (pPtr->left == NULL)
{
pPtr = &userTree[nextAvailableNode];
strcpy (pPtr->label, token);
pPtr->index = j;
nextAvailableNode++;
qPtr->left = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->right == NULL)
{
pPtr = &userTree[nextAvailableNode];
strcpy (pPtr->label, token);
pPtr->index = j;
nextAvailableNode++;
qPtr->right = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->anc == NULL)
{
pPtr = &userTree[nextAvailableNode];
strcpy (pPtr->label, token);
pPtr->index = j;
nextAvailableNode++;
qPtr->anc = pPtr;
pPtr->left = qPtr;
qPtr = pPtr;
userTreeRoot = pPtr;
pPtr->marked = YES;
}
else
{
printf ("\n ERROR: Tree is not bifurcating\n");
return (ERROR);
}
}
else
{
printf ("\n ERROR: Taxon name \"%s\" is not found\n", token);
return (ERROR);
}
break;
case CMD_TREE3:
/* <number> */
if (nextAvailableNode+1 >= 2*nTaxa)
{
printf ("\n ERROR: Too many nodes in tree\n");
return (ERROR);
}
sscanf (token, "%d", &tempInt);
tempInt--;
if (tempInt < 0 || tempInt >= nTaxa)
{
printf ("\n ERROR: Taxon number is out of range\n");
}
else
{
if (pPtr->left == NULL)
{
pPtr = &userTree[nextAvailableNode];
i = 0;
while (taxonLabels[tempInt*100+i] != '|')
{
pPtr->label[i] = taxonLabels[tempInt*100+i];
i++;
}
pPtr->label[i] = '\0';
pPtr->index = tempInt;
nextAvailableNode++;
qPtr->left = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->right == NULL)
{
pPtr = &userTree[nextAvailableNode];
i = 0;
while (taxonLabels[tempInt*100+i] != '|')
{
pPtr->label[i] = taxonLabels[tempInt*100+i];
i++;
}
pPtr->label[i] = '\0';
pPtr->index = tempInt;
nextAvailableNode++;
qPtr->right = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->anc == NULL)
{
pPtr = &userTree[nextAvailableNode];
i = 0;
while (taxonLabels[tempInt*100+i] != '|')
{
pPtr->label[i] = taxonLabels[tempInt*100+i];
i++;
}
pPtr->label[i] = '\0';
pPtr->index = tempInt;
nextAvailableNode++;
qPtr->anc = pPtr;
pPtr->left = qPtr;
qPtr = pPtr;
userTreeRoot = pPtr;
pPtr->marked = YES;
}
else
{
printf ("\n ERROR: Tree is not bifurcating\n");
return (ERROR);
}
}
break;
case CMD_TREE4:
/* ) */
if (pPtr->marked == NO)
{
if (pPtr->anc != NULL)
{
pPtr = pPtr->anc;
qPtr = pPtr;
}
else
{
printf ("\n ERROR: Cannot go down\n");
return (ERROR);
}
}
else
{
if (pPtr->left != NULL)
{
pPtr = pPtr->left;
qPtr = pPtr;
}
else
{
printf ("\n ERROR: Cannot go up\n");
return (ERROR);
}
}
break;
case CMD_TREE5:
/* , */
if (pPtr->marked == NO)
{
if (pPtr->anc != NULL)
{
pPtr = pPtr->anc;
qPtr = pPtr;
}
else
{
printf ("\n ERROR: Cannot go down\n");
return (ERROR);
}
}
else
{
if (pPtr->left != NULL)
{
pPtr = pPtr->left;
qPtr = pPtr;
}
else
{
printf ("\n ERROR: Cannot go up\n");
return (ERROR);
}
}
break;
case CMD_TREE6:
/* : */
break;
case CMD_TREE7:
/* ; */
if (pPtr != &userTree[0])
{
printf ("\n ERROR: Something wrong with user tree\n");
return (ERROR);
}
if (pPtr->anc == NULL)
isTreeRooted = YES;
else
isTreeRooted = NO;
if (isTreeRooted == YES)
{
printf (" User tree defined (rooted)\n");
pPtr = &userTree[nextAvailableNode];
nextAvailableNode++;
pPtr->left = qPtr;
qPtr->anc = pPtr;
userTreeRoot = pPtr;
}
else
{
printf (" User tree defined (unrooted)\n");
}
i = nTaxa;
if (isTreeRooted == YES)
FinishTree (userTreeRoot, &i, YES);
else
FinishTree (userTreeRoot, &i, NO);
isUserTreeDefined = YES;
if (isTreeRooted == YES)
{
if (DerootTree (userTreeRoot) == ERROR)
return (ERROR);
if (RootTree (userTreeRoot) == ERROR)
return (ERROR);
}
else
{
if (RootTree (userTreeRoot) == ERROR)
return (ERROR);
if (DerootTree (userTreeRoot) == ERROR)
return (ERROR);
}
break;
case CMD_TREE8:
/* <branch length> */
sscanf (token, "%lf", &tempD);
if (pPtr->marked == NO)
pPtr->length = tempD;
else
{
if (pPtr->left != NULL)
pPtr->left->length = tempD;
else
{
printf (" ERROR: Cannot assign branch length to left node\n");
printf ("token = %s\n", token);
return (ERROR);
}
}
userBrlensDef = YES;
break;
case CMD_SHOWUSERTREE:
if (isUserTreeDefined == NO)
{
printf (" ERROR: No user tree defined\n");
}
else
{
if (isTreeRooted == YES)
printf ("\n Tree is rooted:\n\n");
else
printf ("\n Tree is unrooted:\n\n");
if (ShowTree (userTreeRoot, isTreeRooted) == ERROR)
{
return (ERROR);
}
else
printf ("\n");
}
break;
case CMD_INIT_ENFORCECAL:
if (token[0] == 'y')
enforceCalibrations = YES;
else
enforceCalibrations = NO;
printf (" Setting enforcecal=%s\n", token);
break;
case CMD_INIT_ENFORCECON:
if (token[0] == 'y')
enforceConstraints = YES;
else
enforceConstraints = NO;
printf (" Setting enforcecon=%s\n", token);
break;
case CMD_INIT_INFERANC:
if (token[0] == 'y')
inferAncStates = YES;
else
inferAncStates = NO;
printf (" Setting inferanc=%s\n", token);
break;
case CMD_INIT_NCAT:
sscanf (token, "%d", &tempInt);
nRateCats = tempInt;
printf (" Setting ncat=%d\n", nRateCats);
break;
case CMD_ROOT_TREE:
if (isUserTreeDefined == NO)
{
printf (" ERROR: No user tree defined\n");
}
else
{
if (isTreeRooted == YES)
{
printf ("\n WARNING: Tree is already rooted\n");
if (DerootTree (userTreeRoot) == ERROR)
return (ERROR);
if (RootTree (userTreeRoot) == ERROR)
return (ERROR);
}
else
{
printf (" Rooting tree\n");
if (RootTree (userTreeRoot) == ERROR)
return (ERROR);
}
}
break;
case CMD_DEROOT_TREE:
if (isUserTreeDefined == NO)
{
printf (" ERROR: No user tree defined\n");
}
else
{
if (isTreeRooted == YES)
{
printf (" Derooting tree\n");
if (DerootTree (userTreeRoot) == ERROR)
return (ERROR);
}
else
{
printf (" WARNING: Tree is already unrooted\n");
if (RootTree (userTreeRoot) == ERROR)
return (ERROR);
if (DerootTree (userTreeRoot) == ERROR)
return (ERROR);
}
}
break;
case CMD_SHOWNODES:
if (isUserTreeDefined == NO)
{
printf (" ERROR: No user tree defined\n");
}
else
{
if (isTreeRooted == YES)
printf ("\n Tree is rooted:\n\n");
else
printf ("\n Tree is unrooted:\n\n");
ShowNodes (userTreeRoot, 2, isTreeRooted);
}
break;
case CMD_SAVEBRLENS:
if (token[0] == 'y')
saveBrlens = YES;
else
saveBrlens = NO;
break;
case CMD_SET_SEQ_ERROR:
sscanf (token, "%lf", &tempD);
if (tempD < 0.0 || tempD > 1.0)
{
printf (" ERROR: Error probability must be between 0 and 1\n");
return (ERROR);
}
seqErrorProb = tempD;
printf (" Setting sequencing error probability\n");
break;
case CMD_SET_SP_RATE:
sscanf (token, "%lf", &tempD);
if (tempD < 0.0)
{
printf (" ERROR: Speciation rate must be greater than zero\n");
return (ERROR);
}
speciationRate = tempD;
printf (" Setting speciation rate\n");
break;
case CMD_SET_EX_RATE:
sscanf (token, "%lf", &tempD);
if (tempD < 0.0)
{
printf (" ERROR: Extinction rate must be greater than zero\n");
return (ERROR);
}
extinctionRate = tempD;
printf (" Setting extinction rate\n");
break;
case CMD_SET_SAMP_FRAC:
sscanf (token, "%lf", &tempD);
if (tempD < 0.0)
{
printf (" ERROR: Taxon sampling fraction must be between 0 and 1.\n");
return (ERROR);
}
samplingFraction = tempD;
printf (" Setting taxon sampling fraction\n");
break;
case CMD_SUMT_FILENAME:
strcpy (sumTreeFile, token);
break;
case CMD_SUMT_BURN:
sscanf (token, "%d", &tempInt);
burnIn = tempInt;
break;
case CMD_SUMT_READFILE:
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
else
{
foundBrlens = NO;
if (SummarizeTrees () == ERROR)
{
printf (" Could not execute file\n");
ErrorExit ();
return (ERROR);
}
}
break;
case CMD_TRANS_INIT:
transNumber = 0;
//printf (" Reading translation table\n");
break;
case CMD_TRANS_NEW_NM:
//printf (" %s", token);
i = 0;
while (token[i] != '\0')
{
transNewNames[transNumber*100+i] = token[i];
i++;
}
transNewNames[transNumber*100+i] = '|';
break;
case CMD_TRANS_OLD_NM:
//printf (" = %s\n", token);
i = 0;
while (token[i] != '\0')
{
transOldNames[transNumber*100+i] = token[i];
i++;
}
transOldNames[transNumber*100+i] = '|';
break;
case CMD_TRANS_COMMA:
transNumber++;
break;
case CMD_TRANS_END:
transNumber++;
/*for (j=0; j<transNumber; j++)
{
printf (" ");
i = 0;
while (transOldNames[j*100+i] != '|')
{
printf ("%c", transOldNames[j*100+i]);
i++;
}
printf (" -> ");
i = 0;
while (transNewNames[j*100+i] != '|')
{
printf ("%c", transNewNames[j*100+i]);
i++;
}
printf ("\n");
}*/
isTranslated = YES;
break;
case CMD_SUM_TREE:
/* = */
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
for (i=0; i<2*nTaxa; i++)
{
sumTree[i].left = NULL;
sumTree[i].right = NULL;
sumTree[i].anc = NULL;
sumTree[i].memoryIndex = i;
sumTree[i].index = i;
sumTree[i].upDateCl = NO;
sumTree[i].length = 0.0;
sumTree[i].marked = NO;
strcpy (sumTree[i].label, "no name");
strcpy (sumTree[i].calibrationName, "no name");
strcpy (sumTree[i].constraintName, "no name");
}
isFirstNode = YES;
pPtr = qPtr = &sumTree[0];
nextAvailableNode = 0;
break;
case CMD_SUM_TREE1:
/* ( */
if (isFirstNode == YES)
{
pPtr = &sumTree[nextAvailableNode];
nextAvailableNode++;
isFirstNode = NO;
sumTreeRoot = pPtr;
}
else
{
if (nextAvailableNode+1 >= 2*nTaxa)
{
printf (" ERROR: Too many nodes in tree\n");
return (ERROR);
}
if (pPtr->left == NULL)
{
pPtr = &sumTree[nextAvailableNode];
nextAvailableNode++;
qPtr->left = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->right == NULL)
{
pPtr = &sumTree[nextAvailableNode];
nextAvailableNode++;
qPtr->right = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->anc == NULL)
{
pPtr = &sumTree[nextAvailableNode];
nextAvailableNode++;
qPtr->anc = pPtr;
pPtr->left = qPtr;
qPtr = pPtr;
sumTreeRoot = pPtr;
pPtr->marked = YES;
}
else
{
printf ("\n ERROR: Tree is not bifurcating\n");
return (ERROR);
}
}
break;
case CMD_SUM_TREE2:
/* <name> */
if (nextAvailableNode+1 >= 2*nTaxa)
{
printf ("\n ERROR: Too many nodes in tree\n");
return (ERROR);
}
if (isTranslated == YES)
{
/* need to use translate table */
/* first, find the name from the tree in the list of new labels */
tempInt = NO;
for (j=0; j<transNumber; j++)
{
i = 0;
while (transNewNames[j*100+i] != '|')
{
tempString[i] = transNewNames[j*100+i];
i++;
}
tempString[i] = '\0';
if (!strcmp(tempString, token))
{
tempInt = YES;
break;
}
}
/* second, get the translated name (the old name is now in tempString) */
if (tempInt == YES)
{
i = 0;
while (transOldNames[j*100+i] != '|')
{
tempString[i] = transOldNames[j*100+i];
i++;
}
tempString[i] = '\0';
}
else
{
printf ("\n ERROR: Taxon name \"%s\" is not found\n", token);
return (ERROR);
}
/* third, find the old name in the list of taxon labels */
tempInt = NO;
for (j=0; j<nTaxa; j++)
{
i = 0;
while (taxonLabels[j*100+i] != '|')
{
tempString2[i] = taxonLabels[j*100+i];
i++;
}
tempString2[i] = '\0';
if (!strcmp(tempString2, tempString))
{
tempInt = YES;
break;
}
}
if (tempInt == NO)
{
printf ("\n ERROR: Taxon name \"%s\" is not found\n", tempString);
return (ERROR);
}
}
else
{
/* no translate table */
tempInt = NO;
for (j=0; j<nTaxa; j++)
{
i = 0;
while (taxonLabels[j*100+i] != '|')
{
tempString[i] = taxonLabels[j*100+i];
i++;
}
tempString[i] = '\0';
if (!strcmp(tempString, token))
{
tempInt = YES;
break;
}
}
if (tempInt == NO)
{
printf ("\n ERROR: Taxon name \"%s\" is not found\n", token);
return (ERROR);
}
}
/* add the node to the tree */
if (pPtr->left == NULL)
{
pPtr = &sumTree[nextAvailableNode];
strcpy (pPtr->label, tempString);
pPtr->index = j;
nextAvailableNode++;
qPtr->left = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->right == NULL)
{
pPtr = &sumTree[nextAvailableNode];
strcpy (pPtr->label, tempString);
pPtr->index = j;
nextAvailableNode++;
qPtr->right = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->anc == NULL)
{
pPtr = &sumTree[nextAvailableNode];
strcpy (pPtr->label, tempString);
pPtr->index = j;
nextAvailableNode++;
qPtr->anc = pPtr;
pPtr->left = qPtr;
qPtr = pPtr;
sumTreeRoot = pPtr;
pPtr->marked = YES;
}
else
{
printf ("\n ERROR: Tree is not bifurcating\n");
return (ERROR);
}
break;
case CMD_SUM_TREE3:
/* <number> */
if (nextAvailableNode+1 >= 2*nTaxa)
{
printf ("\n ERROR: Too many nodes in tree\n");
return (ERROR);
}
if (isTranslated == YES)
{
/* need to use translate table */
/* first, find the name from the tree in the list of new labels */
tempInt = NO;
for (j=0; j<transNumber; j++)
{
i = 0;
while (transNewNames[j*100+i] != '|')
{
tempString[i] = transNewNames[j*100+i];
i++;
}
tempString[i] = '\0';
if (!strcmp(tempString, token))
{
tempInt = YES;
break;
}
}
/* second, get the translated name (the old name is now in tempString) */
if (tempInt == YES)
{
i = 0;
while (transOldNames[j*100+i] != '|')
{
tempString[i] = transOldNames[j*100+i];
i++;
}
tempString[i] = '\0';
}
else
{
printf ("\n ERROR: Taxon name \"%s\" is not found\n", token);
return (ERROR);
}
/* third, find the old name in the list of taxon labels */
tempInt = NO;
for (j=0; j<nTaxa; j++)
{
i = 0;
while (taxonLabels[j*100+i] != '|')
{
tempString2[i] = taxonLabels[j*100+i];
i++;
}
tempString2[i] = '\0';
if (!strcmp(tempString2, tempString))
{
tempInt = YES;
break;
}
}
if (tempInt == NO)
{
printf ("\n ERROR: Taxon name \"%s\" is not found\n", tempString);
return (ERROR);
}
tempInt = j;
}
else
{
/* no translation table */
sscanf (token, "%d", &tempInt);
tempInt--;
if (tempInt < 0 || tempInt >= nTaxa)
{
printf ("\n ERROR: Taxon number is out of range\n");
}
i = 0;
while (taxonLabels[tempInt*100+i] != '|')
{
tempString[i] = taxonLabels[tempInt*100+i];
i++;
}
tempString[i] = '\0';
}
/* add node */
if (pPtr->left == NULL)
{
pPtr = &sumTree[nextAvailableNode];
strcpy (pPtr->label, tempString);
pPtr->index = tempInt;
nextAvailableNode++;
qPtr->left = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->right == NULL)
{
pPtr = &sumTree[nextAvailableNode];
strcpy (pPtr->label, tempString);
pPtr->index = tempInt;
nextAvailableNode++;
qPtr->right = pPtr;
pPtr->anc = qPtr;
qPtr = pPtr;
}
else if (pPtr->anc == NULL)
{
pPtr = &sumTree[nextAvailableNode];
strcpy (pPtr->label, tempString);
pPtr->index = tempInt;
nextAvailableNode++;
qPtr->anc = pPtr;
pPtr->left = qPtr;
qPtr = pPtr;
sumTreeRoot = pPtr;
pPtr->marked = YES;
}
else
{
printf ("\n ERROR: Tree is not bifurcating\n");
return (ERROR);
}
break;
case CMD_SUM_TREE4:
/* ) */
if (pPtr->marked == NO)
{
if (pPtr->anc != NULL)
{
pPtr = pPtr->anc;
qPtr = pPtr;
}
else
{
printf ("\n ERROR: Cannot go down\n");
return (ERROR);
}
}
else
{
if (pPtr->left != NULL)
{
pPtr = pPtr->left;
qPtr = pPtr;
}
else
{
printf ("\n ERROR: Cannot go up\n");
return (ERROR);
}
}
break;
case CMD_SUM_TREE5:
/* , */
if (pPtr->marked == NO)
{
if (pPtr->anc != NULL)
{
pPtr = pPtr->anc;
qPtr = pPtr;
}
else
{
printf ("\n ERROR: Cannot go down\n");
return (ERROR);
}
}
else
{
if (pPtr->left != NULL)
{
pPtr = pPtr->left;
qPtr = pPtr;
}
else
{
printf ("\n ERROR: Cannot go up\n");
return (ERROR);
}
}
break;
case CMD_SUM_TREE6:
/* : */
break;
case CMD_SUM_TREE7:
/* ; */
numSumTrees++;
if (numSumTrees % 1000 == 0)
printf (" Reading tree %d\n", numSumTrees);
//printf ("Reading tree %d\n", numSumTrees);
if (pPtr != &sumTree[0])
{
printf ("\n ERROR: Something wrong with user tree\n");
return (ERROR);
}
if (pPtr->anc == NULL)
isSumTreeRooted = YES;
else
isSumTreeRooted = NO;
if (isSumTreeRooted == YES)
{
//printf (" Tree read (rooted) %d\n", numSumTrees);
pPtr = &sumTree[nextAvailableNode];
nextAvailableNode++;
pPtr->left = qPtr;
qPtr->anc = pPtr;
sumTreeRoot = pPtr;
}
else
{
//printf (" Tree read (unrooted) %d\n", numSumTrees);
}
i = nTaxa;
if (isSumTreeRooted == YES)
FinishTree (sumTreeRoot, &i, YES);
else
FinishTree (sumTreeRoot, &i, NO);
if (isSumTreeRooted == YES)
{
if (DerootSumTree (sumTreeRoot) == ERROR)
return (ERROR);
if (RootSumTree (sumTreeRoot) == ERROR)
return (ERROR);
}
else
{
if (RootSumTree (sumTreeRoot) == ERROR)
return (ERROR);
if (DerootSumTree (sumTreeRoot) == ERROR)
return (ERROR);
}
# if 0
if (ShowTree (sumTreeRoot, isSumTreeRooted) == ERROR)
{
printf (" ERROR: Could not show tree\n");
return (ERROR);
}
# endif
/* allocate space for down pass sequence, if this is the first tree read in */
if (isSumTreeRooted == YES)
nNodes = 2 * nTaxa;
else
nNodes = 2 * nTaxa - 2;
if (numSumTrees == 1)
{
sumTreeDP = (TreeNode **)malloc((size_t) (2 * nTaxa * sizeof(TreeNode *)));
if (!sumTreeDP)
{
printf (" ERROR: Could not allocate sumTreeDP\n");
return (ERROR);
}
}
/* set up bits, if this is the first tree read in */
if (numSumTrees == 1)
{
if (SetBits (nTaxa) == ERROR)
return (ERROR);
}
/* get size of unsigned */
unsignedIntsize = sizeof(unsigned);
/* get down pass sequence */
i = 0;
GetUserDownPass (sumTreeRoot, sumTreeDP, &i);
/* pass down tree, assigning bits for each node */
for (i=0; i<nNodes; i++)
{
p = sumTreeDP[i];
for (j=0; j<nUnsignedNeeded; j++)
treeBits[(p->index)*nUnsignedNeeded + j] = 0;
if (p->left == NULL && p->right == NULL && p->anc != NULL)
{
offSet = 0;
while ((p->index+1) > unsignedIntsize*8*(offSet+1))
offSet++;
x = 1 << (p->index - offSet*unsignedIntsize*8);
treeBits[(p->index)*nUnsignedNeeded + offSet] = x;
}
else if (p->left != NULL && p->right == NULL && p->anc == NULL && isSumTreeRooted == NO)
{
offSet = 0;
while ((p->index+1) > unsignedIntsize*8*(offSet+1))
offSet++;
x = 1;
x <<= (p->index - offSet*unsignedIntsize*8);
treeBits[(p->index)*nUnsignedNeeded + offSet] = x;
}
else if (p->left != NULL && p->right != NULL && p->anc != NULL)
{
for (j=0; j<nUnsignedNeeded; j++)
{
treeBits[(p->index)*nUnsignedNeeded + j] =
treeBits[(p->left->index)*nUnsignedNeeded + j] | treeBits[(p->right->index)*nUnsignedNeeded + j];
}
}
/*printf ("%4d: ", p->index);
for (j=nUnsignedNeeded-1; j>=0; j--)
DisplayBits (treeBits[(p->index)*nUnsignedNeeded + j]);
printf ("\n");*/
}
/* flip bits, if necessary (first taxon is always 0) */
if (isSumTreeRooted == NO)
{
for (i=0; i<nNodes; i++)
{
x = treeBits[i * nUnsignedNeeded + 0];
y = 1;
if ((x & y) == 1)
{
//printf ("flipping bits:\n");
for (j=0; j<nUnsignedNeeded; j++)
{
x = treeBits[i * nUnsignedNeeded + j];
y = taxonMask[j];
treeBits[i * nUnsignedNeeded + j] = x ^ y;
/*printf ("%4d: ", p->index);
for (j=nUnsignedNeeded-1; j>=0; j--)
DisplayBits (treeBits[(p->index)*nUnsignedNeeded + j]);
printf ("\n");*/
}
}
}
}
/* tally each partition and branch length */
if (numSumTrees > burnIn)
{
numSumTreesSampled++;
for (i=0; i<nNodes; i++)
{
p = sumTreeDP[i];
if (p->anc != NULL)
{
if (p->anc->anc != NULL)
{
foundPartition = NO;
for (k=0; k<numTreePartsFound; k++)
{
allSame = YES;
for (j=0; j<nUnsignedNeeded; j++)
{
if (treeBits[(p->index)*nUnsignedNeeded + j] != treePartsFound[k*nUnsignedNeeded + j])
{
allSame = NO;
break;
}
}
if (allSame == YES)
{
numFoundOfThisPart[k]++;
foundPartition = YES;
aOldBrlens[k] = aBrlens[k];
aBrlens[k] = aOldBrlens[k] + (p->length - aOldBrlens[k]) / (numFoundOfThisPart[k]);
sBrlens[k] = sBrlens[k] + (p->length - aOldBrlens[k]) * (p->length - aOldBrlens[k]);
break;
}
}
if (foundPartition == NO)
{
if (numTreePartsFound+1 == numPartsAllocated)
{
if (RealloateTreeParts () == ERROR)
{
printf (" ERROR: Could not increase size of partitions.\n");
return (ERROR);
}
}
for (j=0; j<nUnsignedNeeded; j++)
treePartsFound[numTreePartsFound*nUnsignedNeeded + j] = treeBits[(p->index)*nUnsignedNeeded + j];
numFoundOfThisPart[numTreePartsFound] = 1;
aBrlens[numTreePartsFound] = p->length;
sBrlens[numTreePartsFound] = 0.0;
numTreePartsFound++;
}
}
}
else
{
if (isSumTreeRooted == NO)
{
foundPartition = NO;
for (k=0; k<numTreePartsFound; k++)
{
allSame = YES;
for (j=0; j<nUnsignedNeeded; j++)
{
if (treeBits[(p->index)*nUnsignedNeeded + j] != treePartsFound[k*nUnsignedNeeded + j])
{
allSame = NO;
break;
}
}
if (allSame == YES)
{
numFoundOfThisPart[k]++;
foundPartition = YES;
aOldBrlens[k] = aBrlens[k];
aBrlens[k] = aOldBrlens[k] + (p->left->length - aOldBrlens[k]) / (numFoundOfThisPart[k]);
sBrlens[k] = sBrlens[k] + (p->left->length - aOldBrlens[k]) * (p->left->length - aOldBrlens[k]);
break;
}
}
if (foundPartition == NO)
{
if (numTreePartsFound+1 == numPartsAllocated)
{
if (RealloateTreeParts () == ERROR)
{
printf (" ERROR: Could not increase size of partitions.\n");
return (ERROR);
}
}
for (j=0; j<nUnsignedNeeded; j++)
treePartsFound[numTreePartsFound*nUnsignedNeeded + j] = treeBits[(p->index)*nUnsignedNeeded + j];
numFoundOfThisPart[numTreePartsFound] = 1;
aBrlens[numTreePartsFound] = p->left->length;
sBrlens[numTreePartsFound] = 0.0;
numTreePartsFound++;
}
}
}
}
}
# if 0
printf (" Tree %d:\n", numSumTrees);
if (ShowTree (sumTreeRoot, isSumTreeRooted) == ERROR)
{
return (ERROR);
}
# endif
# if 0
ShowNodes (sumTreeRoot, 2, isSumTreeRooted);
# endif
break;
case CMD_SUM_TREE8:
/* <branch length> */
sscanf (token, "%lf", &tempD);
if (pPtr->marked == NO)
pPtr->length = tempD;
else
{
if (pPtr->left != NULL)
pPtr->left->length = tempD;
else
{
printf (" ERROR: Cannot assign branch length to left node\n");
printf ("token = %s\n", token);
return (ERROR);
}
}
foundBrlens = YES;
break;
case CMD_INIT_TREE_BLK:
isTranslated = NO;
numSumTrees = 0;
numSumTreesSampled = 0;
break;
case CMD_SUM_TREE_END:
printf (" Read %d trees from file, %d of which were sampled\n", numSumTrees, numSumTreesSampled);
if (numSumTreesSampled == 0)
{
printf ("\n ERROR: No trees read in.\n\n", conFile);
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
unsignedIntsize = sizeof(unsigned);
/* sort partitions */
SortParts (numFoundOfThisPart, numTreePartsFound);
/* print partitions */
strcpy (conFile, sumTreeFile);
strcat (conFile, ".parts");
if ((fp = fopen (conFile, "w")) == NULL)
{
printf ("\n ERROR: Could not open file \"%s\"\n\n", conFile);
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
printf ("\n");
printf (" General explanation:\n\n");
printf (" A taxon bipartition is specified by removing a\n");
printf (" branch, dividing the species into those to the\n");
printf (" left and those to the right of the branch. Here,\n");
printf (" taxa to one side of the removed branch are denoted\n");
printf (" \".\" and those to the other side are denoted \"*\".\n");
printf (" The output includes the bipartition number (sorted\n");
printf (" from highest to lowest probability), bipartition\n");
printf (" (e.g., ...**..), number of times the bipartition\n");
printf (" was observed, the posterior probability of the \n");
printf (" bipartition, and, if branch lengths were recorded \n");
printf (" on the trees in the file, the average and variance\n");
printf (" of the branch lengths. Each \".\" or \"*\" in the\n");
printf (" bipartition represents a taxon that is to the left \n");
printf (" or right of the removed branch. A list of the taxa \n");
printf (" in the bipartitions is listed before the list of \n");
printf (" bipartitions. \n\n");
printf (" List of taxa in bipartitions:\n\n");
for (k=0; k<nTaxa; k++)
{
printf (" %4d -- ", k+1);
i = 0;
while (taxonLabels[k*100+i] != '|')
{
printf ("%c", taxonLabels[k*100+i]);
i++;
}
printf ("\n");
}
printf ("\n");
printf (" List of taxon bipartitions found in tree file:\n\n");
fprintf (fp, " General explanation:\n\n");
fprintf (fp, " A taxon bipartition is specified by removing a\n");
fprintf (fp, " branch, dividing the species into those to the\n");
fprintf (fp, " left and those to the right of the branch. Here,\n");
fprintf (fp, " taxa to one side of the removed branch are denoted\n");
fprintf (fp, " \".\" and those to the other side are denoted \"*\".\n");
fprintf (fp, " The output includes the bipartition number (sorted\n");
fprintf (fp, " from highest to lowest probability), bipartition\n");
fprintf (fp, " (e.g., ...**..), number of times the bipartition\n");
fprintf (fp, " was observed, the posterior probability of the \n");
fprintf (fp, " bipartition, and, if branch lengths were recorded \n");
fprintf (fp, " on the trees in the file, the average and variance\n");
fprintf (fp, " of the branch lengths. Each \".\" or \"*\" in the\n");
fprintf (fp, " bipartition represents a taxon that is to the left \n");
fprintf (fp, " or right of the removed branch. A list of the taxa \n");
fprintf (fp, " in the bipartitions is listed before the list of \n");
fprintf (fp, " bipartitions. \n\n");
fprintf (fp, " List of taxa in bipartitions:\n\n");
for (k=0; k<nTaxa; k++)
{
fprintf (fp, " %4d -- ", k+1);
i = 0;
while (taxonLabels[k*100+i] != '|')
{
fprintf (fp, "%c", taxonLabels[k*100+i]);
i++;
}
fprintf (fp, "\n");
}
fprintf (fp, "\n");
fprintf (fp, " List of taxon bipartitions found in tree file:\n\n");
for (k=0; k<numTreePartsFound; k++)
{
printf (" %4d -- ", k+1);
fprintf (fp, "%d\t", k+1);
offSet = 0;
x = 1;
for (j=0; j<nTaxa; j++)
{
if (treePartsFound[k*nUnsignedNeeded + offSet] & x)
{
printf ("*");
fprintf (fp, "*");
}
else
{
printf (".");
fprintf (fp, ".");
}
x <<= 1;
if (j+1 >= unsignedIntsize*8*(offSet+1))
{
offSet++;
x = 1;
}
}
if (foundBrlens == YES)
{
printf (" -- %5d %1.6lf %1.8lf (%1.8lf)\n",
numFoundOfThisPart[k], (double)numFoundOfThisPart[k]/numSumTreesSampled, aBrlens[k], (double)sBrlens[k]/(numSumTreesSampled-1));
fprintf (fp, "\t%d\t%1.6lf\t%1.8lf\t%1.8lf\n",
numFoundOfThisPart[k], (double)numFoundOfThisPart[k]/numSumTreesSampled, aBrlens[k], (double)sBrlens[k]/(numSumTreesSampled-1));
}
else
{
printf (" -- %5d %1.6lf\n",
numFoundOfThisPart[k], (double)numFoundOfThisPart[k]/numSumTreesSampled);
fprintf (fp, "\t%d\t%1.6lf\n",
numFoundOfThisPart[k], (double)numFoundOfThisPart[k]/numSumTreesSampled);
}
}
# if !defined (CONTREE)
fclose (fp);
# endif
# if defined (CONTREE)
/* allocate space for consensus tree nodes */
conNodes = (PolyNode *)malloc((size_t) (2 * nTaxa * sizeof(PolyNode)));
if (!conNodes)
{
printf (" ERROR: Could not allocate conNodes\n");
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
fclose(fp);
ErrorExit ();
return (ERROR);
}
/* transform taxonLabels */
for (i=0; i<nTaxa*100; i++)
if (taxonLabels[i] == '|')
taxonLabels[i] = '\0';
/* initialize terminal consensus nodes */
for (i=0; i<nTaxa; i++)
{
conNodes[i].left = NULL;
conNodes[i].sib = NULL;
conNodes[i].index = i;
conNodes[i].label = &taxonLabels[i*100];
}
# else
constraintTree = (ConTreeNode *)malloc((size_t) (2 * nTaxa * sizeof(ConTreeNode)));
if (!constraintTree)
{
printf (" ERROR: Could not allocate constraintTree\n");
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
taxaInConstraint = (ConTreeNode **)malloc((size_t) (nTaxa * sizeof(ConTreeNode *)));
if (!taxaInConstraint)
{
printf (" ERROR: Could not allocate taxaInConstraint\n");
free (constraintTree);
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
taxaNotInConstraint = (ConTreeNode **)malloc((size_t) (nTaxa * sizeof(ConTreeNode *)));
if (!taxaNotInConstraint)
{
printf (" ERROR: Could not allocate taxaNotInConstraint\n");
free (constraintTree);
free (taxaInConstraint);
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
for (i=0; i<2*nTaxa; i++)
{
constraintTree[i].left = NULL;
constraintTree[i].leftSib = NULL;
constraintTree[i].rightSib = NULL;
constraintTree[i].anc = NULL;
constraintTree[i].index = i;
constraintTree[i].length = 0.0;
strcpy (constraintTree[i].label, "no name");
}
for (i=0; i<nTaxa; i++)
taxaInConstraint[i] = taxaInConstraint[i] = NULL;
compatParts = (unsigned *)malloc((size_t) (2 * nTaxa * nUnsignedNeeded * sizeof(unsigned)));
if (!compatParts)
{
printf (" ERROR: Could not allocate compatParts\n");
free (constraintTree);
free (taxaNotInConstraint);
free (taxaInConstraint);
free (compatParts);
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
for (i=0; i<2*nTaxa*nUnsignedNeeded; i++)
compatParts[i] = 0;
tempParts = (unsigned *)malloc((size_t) (nUnsignedNeeded * sizeof(unsigned)));
if (!tempParts)
{
printf (" ERROR: Could not allocate tempParts\n");
free (constraintTree);
free (taxaNotInConstraint);
free (taxaInConstraint);
free (compatParts);
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
for (i=0; i<nUnsignedNeeded; i++)
tempParts[i] = 0;
numOnes = (int *)malloc((size_t) (2 * nTaxa * sizeof(int)));
if (!numOnes)
{
printf (" ERROR: Could not allocate numOnes\n");
free (constraintTree);
free (taxaNotInConstraint);
free (taxaInConstraint);
free (compatParts);
free (tempParts);
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
for (i=0; i<2*nTaxa; i++)
numOnes[i] = 0;
partLengths = (double *)malloc((size_t) (2 * nTaxa * sizeof(double)));
if (!partLengths)
{
printf (" ERROR: Could not allocate numOnes\n");
free (constraintTree);
free (taxaNotInConstraint);
free (taxaInConstraint);
free (compatParts);
free (tempParts);
free (numOnes);
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
for (i=0; i<2*nTaxa; i++)
partLengths[i] = 0.0;
#endif
#if defined (CONTREE)
// allocate space for ingroup and outgroup partitions
outgroupPartition = (unsigned int *) calloc (2 * nUnsignedNeeded, sizeof(unsigned int));
ingroupPartition = outgroupPartition + nUnsignedNeeded;
if (!outgroupPartition)
{
printf (" ERROR: Could not allocate outgroupPartition and ingroupPartition\n");
free (conNodes);
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
fclose (fp);
ErrorExit();
return ERROR;
}
// set lastMask - needed to trim last element in partition
// this could be done when a new matrix is read in
// and adjusted when taxa are deleted or restored
j = nTaxa % (unsignedIntsize * 8);
lastMask = 1;
for (i=1; i<j; i++)
lastMask |= (lastMask<<1);
// set ingroup and outgroup partitions
// this could be done when a new matrix is read in
// and adjusted when an outgroup command is issued
// this mechanism allows multiple taxa in outgroup
x = 1;
x <<= outgroupNum % (unsignedIntsize * 8);
i = outgroupNum / (unsignedIntsize * 8);
outgroupPartition[i] = x;
for (i = 0; i < nUnsignedNeeded; i++)
ingroupPartition[i] = outgroupPartition[i];
FlipBits(ingroupPartition, nUnsignedNeeded, lastMask);
/* create bush */
/* ->x counts number of subtended terminals */
/* make sure conRoot->left is in outgroup */
conRoot = &conNodes[nTaxa];
conRoot->anc = conRoot->sib = NULL;
conRoot->x = nTaxa;
j = FirstTaxonInPartition(outgroupPartition, nUnsignedNeeded);
conRoot->left = cp = &conNodes[j];
cp->anc = conRoot;
cp->x = 1;
for (i=0; i<nTaxa; i++)
{
if (i != j)
{
cp->sib = &conNodes[i];
cp = cp->sib;
cp->anc = conRoot;
cp->x = 1;
}
}
cp->sib = NULL;
/* resolve bush according to partitions */
/* partitions may include incompatible ones */
/* partitions should be sorted from more frequent to less frequent */
/* for quit test to work when a 50% maj rule tree is requested */
nextConNode = nTaxa + 1;
if (isSumTreeRooted)
targetNode = 2*nTaxa - 2;
else
targetNode = 2*nTaxa - 3;
for (i=0; i<numTreePartsFound; i++)
{
// calculate frequency and test if time to quit
if (nextConNode > targetNode)
break;
freq = (double)numFoundOfThisPart[i]/ (double)numSumTreesSampled;
if (freq < 0.50 && consensusType == HALF_COMPAT)
break;
// get partition
partition = &treePartsFound[i*nUnsignedNeeded];
// flip bits if necessary
if(!isSumTreeRooted)
{
if (!IsPartNested(partition, ingroupPartition, nUnsignedNeeded)
&& !IsPartCompatible(partition, ingroupPartition, nUnsignedNeeded))
FlipBits(partition, nUnsignedNeeded, lastMask);
}
// count bits in this partition
for (j=nBits=0; j<nUnsignedNeeded; j++)
{
x = partition[j];
for (x = partition[j]; x != 0; x &= (x - 1))
nBits++;
}
// flip this partition if it leaves single outgroup outside
if (nBits == nTaxa - 1 && !isSumTreeRooted)
{
nBits = 1;
FlipBits(partition, nUnsignedNeeded, lastMask);
}
if (nBits > 1)
// this is an informative partition
{
// find anc of partition
j = FirstTaxonInPartition (partition, nUnsignedNeeded);
for (cp = &conNodes[j]; cp!=NULL; cp = cp->anc)
if (cp->x > nBits)
break;
// do not include if incompatible with ancestor
// or any of descendants
// do not check terminals or root because it is
// redundant and partitions have not been set for those
isCompat = YES;
if (cp->anc != NULL && !IsPartCompatible(partition, cp->partition, nUnsignedNeeded))
isCompat = NO;
for (q=cp->left; q!=NULL; q=q->sib)
{
if (q->x > 1 && !IsPartCompatible(q->partition, partition, nUnsignedNeeded))
isCompat = NO;
if (isCompat == NO)
break;
}
if (isCompat == NO)
continue;
// set new node
q = &conNodes[nextConNode++];
q->length = aBrlens[i];
q->support = freq * 100;
q->x = nBits;
q->partition = partition;
// go through descendants of anc
ql = pl = NULL;
for (r=cp->left; r!=NULL; r=r ->sib)
{
// test if r is in the new partition or not
if ((r->x > 1 && IsPartNested(r->partition, partition, nUnsignedNeeded))
|| (r->x == 1 && (partition[r->index / (unsignedIntsize * 8)] & (1 << (r->index % (unsignedIntsize * 8)))) != 0))
{
// r is in the partition
if (ql == NULL)
q->left = r;
else
ql->sib = r;
ql = r;
r->anc = q;
}
else
{
// r is not in the partition
if (pl == NULL)
cp->left = r;
else
pl->sib = r;
pl = r;
}
}
// terminate new sib-node chain
ql->sib = NULL;
// new node is last in old sib-node chain
pl->sib = q;
q->sib = NULL;
q->anc = cp;
}
else
// singleton partition
{
j = FirstTaxonInPartition(partition, nUnsignedNeeded);
q = &conNodes[j];
q->length = aBrlens[i];
q->support = freq * 100;
}
}
/* draw tree to stdout and fp */
fprintf(fp,"\nClade credibility values:\n\n");
printf("\nClade credibility values:\n\n");
ShowConTree (stdout, nextConNode, conRoot, 80);
ShowConTree (fp, nextConNode, conRoot, 80);
if (foundBrlens == YES)
{
fprintf(fp,"Phylogram:\n\n");
printf("Phylogram:\n\n");
ShowConPhylogram (stdout, nextConNode, conRoot, 80);
ShowConPhylogram (fp, nextConNode, conRoot, 80);
}
fclose (fp);
/* reset taxonLabels */
for (i=0; i<nTaxa*100; i++)
if (taxonLabels[i] == '\0')
taxonLabels[i] = '|';
#else
/* make a list of compatible partitions */
nCompatParts = 0;
for (k=0; k<numTreePartsFound; k++)
{
if (k == 0)
{
for (j=0; j<nUnsignedNeeded; j++)
compatParts[nCompatParts*nUnsignedNeeded + j] = treePartsFound[k*nUnsignedNeeded + j];
partLengths[nCompatParts] = aBrlens[k];
nCompatParts++;
}
else
{
for (i=0; i<nCompatParts; i++)
{
for (j=0; j<nUnsignedNeeded; j++)
tempParts[j] = treePartsFound[k*nUnsignedNeeded + j] & compatParts[i*nUnsignedNeeded + j];
isCompat = YES;
for (j=0; j<nUnsignedNeeded; j++)
if (tempParts[j] != 0)
isCompat = NO;
nSame1 = 0;
for (j=0; j<nUnsignedNeeded; j++)
if (tempParts[j] == treePartsFound[k*nUnsignedNeeded + j])
nSame1++;
nSame2 = 0;
for (j=0; j<nUnsignedNeeded; j++)
if (tempParts[j] == compatParts[i*nUnsignedNeeded + j])
nSame2++;
if (isCompat == NO && nSame1 == nUnsignedNeeded)
isCompat = YES;
if (isCompat == NO && nSame2 == nUnsignedNeeded)
isCompat = YES;
if ((double)numFoundOfThisPart[k]/numSumTreesSampled < 0.50 && consensusType == HALF_COMPAT)
isCompat = NO;
if (isCompat == NO)
break;
}
if (isCompat == YES)
{
if (nCompatParts >= 2*nTaxa)
{
printf (" ERROR: Too many compatible partitions found.\n");
free (constraintTree);
free (taxaNotInConstraint);
free (taxaInConstraint);
free (compatParts);
free (tempParts);
free (numOnes);
free (partLengths);
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
for (j=0; j<nUnsignedNeeded; j++)
compatParts[nCompatParts*nUnsignedNeeded + j] = treePartsFound[k*nUnsignedNeeded + j];
partLengths[nCompatParts] = aBrlens[k];
nCompatParts++;
}
}
}
/* count the number of ones in each partition */
for (i=0; i<nCompatParts; i++)
{
offSet = 0;
x = 1;
k = 0;
for (j=0; j<nTaxa; j++)
{
if (compatParts[i*nUnsignedNeeded + offSet] & x)
k++;
x <<= 1;
if (j+1 >= unsignedIntsize*8*(offSet+1))
{
offSet++;
x = 1;
}
}
numOnes[i] = k;
}
/* sort partitions from largest to smallest */
SortCompatParts (numOnes, compatParts, partLengths, nCompatParts);
# if 0
for (k=0; k<nCompatParts; k++)
{
printf ("%4d -- ", k+1);
offSet = 0;
x = 1;
for (j=0; j<nTaxa; j++)
{
if (compatParts[k*nUnsignedNeeded + offSet] & x)
printf ("*");
else
printf (".");
x <<= 1;
if (j+1 >= unsignedIntsize*8*(offSet+1))
{
offSet++;
x = 1;
}
}
printf (" -- %5d %lf\n",
numOnes[k], partLengths[k]);
}
# endif
/* set up initial star tree */
conRoot = &constraintTree[2*nTaxa-1];
cq = NULL;
for (i=0; i<nTaxa; i++)
{
cp = &constraintTree[i];
cp->length = 0.0;
cp->anc = conRoot;
if (cq != NULL)
cq->rightSib = cp;
else
cp->anc->left = cp;
cq = cp;
}
nextConNode = nTaxa;
/* build up constraint tree with compatible partitions */
for (i=0; i<nCompatParts; i++)
{
/* make a list of taxa in constraint */
nTaxaInConstraint = 0;
for (j=0; j<nTaxa; j++)
{
offSet = 0;
x = 1;
for (j=0; j<nTaxa; j++)
{
if (compatParts[i*nUnsignedNeeded + offSet] & x)
{
taxaInConstraint[nTaxaInConstraint] = &constraintTree[j];
nTaxaInConstraint++;
}
x <<= 1;
if (j+1 >= unsignedIntsize*8*(offSet+1))
{
offSet++;
x = 1;
}
}
}
# if 0
printf ("in: ");
for (j=0; j<nTaxaInConstraint; j++)
printf ("%d ", taxaInConstraint[j]->index);
printf ("\n");
# endif
/* get pointer to ancestor */
cp = taxaInConstraint[0]->anc;
isCompat = YES;
for (j=0; j<nTaxaInConstraint; j++)
{
if (taxaInConstraint[j]->anc != cp)
{
isCompat = NO;
break;
}
}
if (isCompat == NO)
{
printf (" ERROR: Strange incompatibility in consensus tree found.\n");
free (constraintTree);
free (taxaNotInConstraint);
free (taxaInConstraint);
free (compatParts);
free (tempParts);
free (numOnes);
free (partLengths);
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
//printf ("cp = %d (", cp->index);
/* get old left-most node */
cl = cp->left;
/* get old right-most node */
for (cq = cp->left; cq != NULL; cq = cq->rightSib)
{
if (cq != NULL)
if (cq->rightSib == NULL)
cr = cq;
//printf ("%d ", cq->index);
}
//printf (")\n");
//printf ("cr = %d\n", cr->index);
/* make a list of nodes not in constraint */
nTaxaNotInConstraint = 0;
for (cq = cp->left; cq != NULL; cq = cq->rightSib)
{
tempInt = NO;
for (j=0; j<nTaxaInConstraint; j++)
{
if (taxaInConstraint[j] == cq)
{
tempInt = YES;
break;
}
}
if (tempInt == NO)
{
taxaNotInConstraint[nTaxaNotInConstraint++] = cq;
}
}
# if 0
printf ("not in: ");
for (j=0; j<nTaxaNotInConstraint; j++)
printf ("%d ", taxaNotInConstraint[j]->index);
printf ("\n");
# endif
/* set up constraint */
if (numOnes[i] > 1)
{
/* get new node */
if (nextConNode + 1 < 2*nTaxa - 1)
{
cn = &constraintTree[nextConNode++];
cn->length = partLengths[i];
}
else
{
printf ("new = PROBLEM!\n");
}
cp->left = cn;
cn->anc = cp;
if (nTaxaNotInConstraint == 0)
cn->rightSib = NULL;
else
{
cn->rightSib = taxaNotInConstraint[0];
for (j=0; j<nTaxaNotInConstraint; j++)
{
cq = taxaNotInConstraint[j];
if (j+1 < nTaxaNotInConstraint)
cq->rightSib = taxaNotInConstraint[j+1];
else
cq->rightSib = NULL;
}
}
cn->left = taxaInConstraint[0];
for (j=0; j<nTaxaInConstraint; j++)
{
cq = taxaInConstraint[j];
cq->anc = cn;
if (j+1 < nTaxaInConstraint)
cq->rightSib = taxaInConstraint[j+1];
else
cq->rightSib = NULL;
}
}
else
{
offSet = 0;
x = 1;
for (j=0; j<nTaxa; j++)
{
if (compatParts[i*nUnsignedNeeded + offSet] & x)
{
cn = &constraintTree[j];
cn->length = partLengths[i];
break;
}
x <<= 1;
if (j+1 >= unsignedIntsize*8*(offSet+1))
{
offSet++;
x = 1;
}
}
}
}
/*for (i=0; i<2*nTaxa; i++)
{
cp = &constraintTree[i];
printf ("%4d (%d %d %d)\n",
Dex3(cp), Dex3(cp->left), Dex3(cp->rightSib), Dex3(cp->anc));
}
printf ("conRoot = %d\n", conRoot->index);*/
#endif
/* write constraint tree */
strcpy (conFile, sumTreeFile);
strcat (conFile, ".con");
if ((fp = fopen (conFile, "w")) == NULL)
{
printf ("\n ERROR: Could not open file \"%s\"\n\n", conFile);
# if !defined (CONTREE)
free (constraintTree);
free (taxaNotInConstraint);
free (taxaInConstraint);
free (compatParts);
free (tempParts);
free (numOnes);
free (partLengths);
# else
free (conNodes);
free (outgroupPartition);
# endif
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
ErrorExit ();
return (ERROR);
}
fprintf (fp, "#NEXUS\n\n");
fprintf (fp, "begin trees;\n");
if (isTranslated == YES)
{
fprintf (fp, "translate\n");
for (j=0; j<transNumber; j++)
{
fprintf (fp, " ");
i = 0;
# if defined (CONTREE) /* correct order in translate block! */
//while (transNewNames[j*100+i] != '|')
while (transOldNames[j*100+i] != '|')
# else
while (transOldNames[j*100+i] != '|')
# endif
{
fprintf (fp, "%c", transOldNames[j*100+i]);
i++;
}
fprintf (fp, " ");
i = 0;
# if defined (CONTREE) /* correct order in translate block! */
//while (transOldNames[j*100+i] != '|')
while (transNewNames[j*100+i] != '|')
# else
while (transNewNames[j*100+i] != '|')
# endif
{
fprintf (fp, "%c", transNewNames[j*100+i]);
i++;
}
if (j == transNumber - 1)
fprintf (fp, ";\n");
else
fprintf (fp, ",\n");
}
}
else
{
fprintf (fp, "translate\n");
for (j=0; j<nTaxa; j++)
{
fprintf (fp, " ");
fprintf (fp, "%d ", j+1);
i = 0;
while (taxonLabels[j*100+i] != '|')
{
fprintf (fp, "%c", taxonLabels[j*100+i]);
i++;
}
if (j == transNumber - 1)
fprintf (fp, ";\n");
else
fprintf (fp, ",\n");
}
}
if (consensusType == HALF_COMPAT)
fprintf (fp, " tree con_50_majrule = ");
else
fprintf (fp, " tree con_all_compat = ");
# if defined (CONTREE)
WriteConTree (conRoot, fp);
# else
WriteConTreeToScreen (conRoot, fp);
# endif
fprintf (fp, ";\n");
fprintf (fp, "end;\n");
fclose (fp);
# if defined (CONTREE)
free (conNodes);
free (outgroupPartition);
# else
free (constraintTree);
free (taxaNotInConstraint);
free (taxaInConstraint);
free (compatParts);
free (tempParts);
free (numOnes);
free (partLengths);
# endif
free (sumTreeDP);
free (treeBits);
free (treePartsFound);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
free (taxonMask);
break;
case CMD_SUMT_HALFCOMP:
consensusType = HALF_COMPAT;
break;
case CMD_SUMT_ALLCOMP:
consensusType = ALL_COMPAT;
break;
case CMD_SUMP_FILENAME:
strcpy (sumParmFile, token);
break;
case CMD_SUMP_BURN:
sscanf (token, "%d", &tempInt);
paramBurn = tempInt;
break;
case CMD_SUMP_READFILE:
if (SummarizeParams () == ERROR)
{
printf (" Could not execute file\n");
ErrorExit ();
return (ERROR);
}
break;
case CMD_SUM_PARM1:
nColumns = headerSize = 0;
headerNames = (char *)malloc((size_t) (HEADER_SIZE * sizeof(char)));
if (!headerNames)
{
printf (" ERROR: Could not allocate headerNames\n");
ErrorExit ();
return (ERROR);
}
break;
case CMD_SUM_PARM2:
/* allocate temporary vector */
tempInfo = (double *)malloc((size_t) (whichRow * nColumns * sizeof(double)));
if (!tempInfo)
{
printf (" ERROR: Could not allocate tempInfo\n");
free (headerNames);
free (paramInfo);
ErrorExit ();
return (ERROR);
}
/* lets make a x-y plot showing time vs. lnL */
i = 0;
for (j=0; j<nColumns; j++)
{
k = 0;
while (headerNames[i] != '|' && headerNames[i] != '\0')
tempString[k++] = headerNames[i++];
tempString[k] = '\0';
i++;
//printf ("%s\n", tempString);
if (!strcmp(tempString, "gen"))
whichIsX = j;
if (!strcmp(tempString, "lnl"))
whichIsY = j;
}
minX = minY = 1000000000.0;
maxX = maxY = -1000000000.0;
for (i=0; i<whichRow; i++)
{
if (paramInfo[i * nColumns + whichIsX] < minX)
minX = paramInfo[i * nColumns + whichIsX];
if (paramInfo[i * nColumns + whichIsY] < minY)
minY = paramInfo[i * nColumns + whichIsY];
if (paramInfo[i * nColumns + whichIsX] > maxX)
maxX = paramInfo[i * nColumns + whichIsX];
if (paramInfo[i * nColumns + whichIsY] > maxY)
maxY = paramInfo[i * nColumns + whichIsY];
}
//printf ("%lf %lf %lf %lf\n", minX, maxX, minY, maxY);
for (i=0; i<SCREENWIDTH; i++)
{
numY[i] = 0;
meanY[i] = 0.0;
}
for (i=0; i<whichRow; i++)
{
k = (int)(((paramInfo[i * nColumns + whichIsX]) / (maxX - minX)) * SCREENWIDTH);
if (k >= SCREENWIDTH)
k = SCREENWIDTH - 1;
meanY[k] += paramInfo[i * nColumns + whichIsY];
numY[k]++;
}
printf ("\n\n +");
for (i=0; i<SCREENWIDTH; i++)
printf ("-");
printf ("+ %1.2lf\n", maxY);
for (j=SCREENHEIGTH-1; j>=0; j--)
{
printf (" |");
for (i=0; i<SCREENWIDTH; i++)
{
if (numY[i] > 0)
{
if (meanY[i] / numY[i] > (((maxY - minY)/SCREENHEIGTH)*j)+minY &&
meanY[i] / numY[i] <= (((maxY - minY)/SCREENHEIGTH)*(j+1))+minY)
printf ("*");
else
printf (" ");
}
else
{
printf (" ");
}
}
printf ("|\n");
}
printf (" +");
for (i=0; i<SCREENWIDTH; i++)
{
if (i % (SCREENWIDTH/10) == 0 && i != 0)
printf ("+");
else
printf ("-");
}
printf ("+ %1.2lf\n", minY);
printf (" ^");
for (i=0; i<SCREENWIDTH; i++)
printf (" ");
printf ("^\n");
printf (" %1.0lf", minX);
for (i=0; i<SCREENWIDTH; i++)
printf (" ");
printf ("%1.0lf\n\n", maxX);
printf (" Above is a rough plot of the generation (x-axis) versus the log\n");
printf (" probability of observing the data (y-axis). You can use this\n");
printf (" graph to determine what the burn-in for your analysis should be.\n");
printf (" When the log probability starts to plateau you may be at station-\n");
printf (" arity. Sample trees and parameters after the log probability\n");
printf (" plateaus. Of course, this is not a guarantee that you are at \n");
printf (" stationarity. When possible, run multiple chains starting from \n");
printf (" random trees; if the inferences you make for independent chains\n");
printf (" are the same, this is reasonable evidence that the chains have \n");
printf (" converged. Remember that the burn in is the number of samples\n");
printf (" to discard. There are a total of ngen / samplefreq samples taken\n");
printf (" during a MCMC analysis.\n\n");
printf (" Below is information on the parameters of your evolutionary model.\n");
printf (" The columns give the mean, variance, and 95 percent credible interval\n");
printf (" for each parameter.\n\n\n");
l = 0;
for (j=0; j<nColumns; j++)
{
/* put the contents of a column into a temporary vector */
k = 0;
for (i=0; i<whichRow; i++)
{
if (i >= paramBurn)
tempInfo[k++] = paramInfo[i * nColumns + j];
}
/* sort the contents of the vector */
SortVector (tempInfo, k);
/*for (i=0; i<k; i++)
printf ("%d %lf\n", i, tempInfo[i]);*/
/* get the mean and variance */
a = 0.0;
aOld = 0.0;
s = 0.0;
for (i=0; i<k; i++)
{
if (i == 0)
{
a = tempInfo[i];
s = 0;
}
else
{
aOld = a;
a = aOld + (tempInfo[i] - aOld) / (i+1);
s = s + (tempInfo[i] - aOld) * (tempInfo[i] - aOld);
}
}
/* print to the screen */
if (j == 0)
printf (" mean variance (95 percent ci) -- parameter\n");
//printf ("%d %d\n", (int)(k*0.025), (int)(k*0.975));
printf (" %lf %lf (%lf %lf) -- ", a, s / (k-1), tempInfo[(int)(k*0.025)], tempInfo[(int)(k*0.975)]);
while (headerNames[l] != '|' && headerNames[l] != '\0')
{
printf ("%c", headerNames[l]);
l++;
}
l++;
printf ("\n");
}
free (tempInfo);
free (headerNames);
free (paramInfo);
break;
case CMD_SUM_PARM3:
i = 0;
while (token[i] != '\0')
{
if (headerSize >= HEADER_SIZE)
{
printf (" ERROR: The header is too large\n");
free (headerNames);
ErrorExit ();
}
headerNames[headerSize++] = token[i];
i++;
}
nColumns++;
break;
case CMD_SUM_PARM4:
if (headerSize >= HEADER_SIZE)
{
printf (" ERROR: The header is too large\n");
free (headerNames);
ErrorExit ();
}
headerNames[headerSize++] = '|';
break;
case CMD_SUM_PARM5:
if (headerSize+2 >= HEADER_SIZE)
{
printf (" ERROR: The header is too large\n");
free (headerNames);
ErrorExit ();
}
headerNames[headerSize++] = '|';
headerNames[headerSize++] = '\0';
//printf ("header = %s\n", headerNames);
/* allocate memory for data */
paramInfo = (double *)malloc((size_t) (100 * nColumns * sizeof(double)));
if (!paramInfo)
{
printf (" ERROR: Could not allocate paramInfo\n");
free (headerNames);
ErrorExit ();
return (ERROR);
}
curNumRows = 100;
//printf ("number of columns = %d\n", nColumns);
whichColumn = whichRow = 0;
break;
case CMD_SUM_PARM6:
/* data */
tempNumColumns = 0;
break;
case CMD_SUM_PARM7:
sscanf (token, "%lf", &tempD);
if (whichRow == curNumRows)
{
/* reallocate paraminfo */
curNumRows += 100;
paramInfo = (double *)realloc(paramInfo, (size_t) (curNumRows * nColumns * sizeof(double)));
if (!paramInfo)
{
printf (" ERROR: Could not allocate paramInfo\n");
free (headerNames);
free (paramInfo);
ErrorExit ();
return (ERROR);
}
}
if (whichColumn == nColumns)
{
printf (" ERROR: Too many columns\n");
free (headerNames);
free (paramInfo);
ErrorExit ();
return (ERROR);
}
paramInfo[whichRow * nColumns + whichColumn] = tempD;
whichColumn++;
break;
case CMD_SUM_PARM8:
break;
case CMD_SUM_PARM9:
whichColumn = 0;
whichRow++;
break;
case CMD_SUM_PARM10:
sscanf (token, "%lf", &tempD);
if (whichRow == curNumRows)
{
/* reallocate paraminfo */
curNumRows += 100;
paramInfo = (double *)realloc(paramInfo, (size_t) (curNumRows * nColumns * sizeof(double)));
if (!paramInfo)
{
printf (" ERROR: Could not allocate paramInfo\n");
free (headerNames);
free (paramInfo);
ErrorExit ();
return (ERROR);
}
}
if (whichColumn == nColumns)
{
printf (" ERROR: Too many columns\n");
free (headerNames);
free (paramInfo);
ErrorExit ();
return (ERROR);
}
paramInfo[whichRow * nColumns + whichColumn] = tempD * (-1.0);
whichColumn++;
break;
case CMD_AUTOCLOSE1:
autoclose = YES;
printf (" Setting autoclose=yes\n");
break;
case CMD_AUTOCLOSE2:
autoclose = NO;
printf (" Setting autoclose=no\n");
break;
case CMD_NPERB:
sscanf (token, "%d", &tempInt);
nPerturbations = tempInt;
break;
case CMD_MCMCP:
printf (" Setting chain parameters\n");
break;
case CMD_SET_AAMODEL1:
aaModelType = POISSON;
printf (" Setting aamodel=poisson\n");
break;
case CMD_SET_AAMODEL2:
aaModelType = EQUALIN;
printf (" Setting aamodel=equalin\n");
break;
case CMD_SET_AAMODEL3:
aaModelType = JONES;
printf (" Setting aamodel=jones\n");
break;
case CMD_SET_AAMODEL4:
aaModelType = DAYHOFF;
printf (" Setting aamodel=dayhoff\n");
break;
case CMD_SET_AAMODEL5:
aaModelType = GTR;
printf (" Setting aamodel=gtr\n");
break;
case CMD_SET_ANCFILE1:
saveAncFiles = YES;
printf (" Setting ancfile=yes\n");
break;
case CMD_SET_ANCFILE2:
saveAncFiles = NO;
printf (" Setting ancfile=no\n");
break;
case CMD_SET_CODON1:
enforceCodonModel = YES;
printf (" Setting enforcecodon=yes\n");
break;
case CMD_SET_CODON2:
enforceCodonModel = NO;
printf (" Setting enforcecodon=no\n");
break;
case CMD_SET_OMEGAVAR1:
strcpy (codonModelType, token);
printf (" Setting omegavar=equal\n");
break;
case CMD_SET_OMEGAVAR2:
strcpy (codonModelType, token);
printf (" Setting omegavar=ny98\n");
break;
case CMD_SET_OMEGAVAR3:
strcpy (codonModelType, token);
printf (" Setting omegavar=ac1ny98\n");
break;
case CMD_SET_OMEGAVAR4:
strcpy (codonModelType, token);
printf (" Setting omegavar=ac2ny98\n");
break;
case CMD_SET_OMEGAVAR5:
strcpy (codonModelType, token);
printf (" Setting omegavar=covny98\n");
break;
case CMD_SET_OMEGA:
if (token[0] == 'e')
{
strcpy(omegaRatioModel, token);
omegaRatio = 1.0;
}
else
{
strcpy (omegaRatioModel, "user defined");
sscanf (token, "%lf", &tempD);
omegaRatio = tempD;
}
printf (" Setting omega = %lf\n", omegaRatio);
break;
case CMD_OMEGAPR1:
strcpy (omegaprModel, "fixed");
printf (" Fixing omega\n");
break;
case CMD_OMEGAPR2:
strcpy (omegaprModel, "uniform");
printf (" Uniform prior on omega\n");
break;
case CMD_OMEGAPR3:
sscanf (token, "%lf", &tempD);
if (tempD < 0.0)
{
printf (" ERROR: Lower bound on uniform must be positive\n");
return (ERROR);
}
omegaprUni[0] = tempD;
break;
case CMD_OMEGAPR4:
sscanf (token, "%lf", &tempD);
if (tempD <= omegaprUni[0])
{
printf (" ERROR: Upper bound on uniform must be greater than lower bound\n");
return (ERROR);
}
omegaprUni[1] = tempD;
break;
case CMD_OMEGAPR5:
strcpy (omegaprModel, "exponential");
printf (" Exponential prior on omega\n");
break;
case CMD_OMEGAPR6:
sscanf (token, "%lf", &tempD);
if (tempD <= 0.0)
{
printf (" ERROR: Parameter of exponential must be greater than 0.\n");
return (ERROR);
}
omegaprExp = tempD;
break;
case CMD_SET_CODE:
if (token[0] == 'u')
aaCode = UNIV;
else if (token[0] == 'v')
aaCode = VERTMT;
else if (token[0] == 'm' && token[1] == 'y')
aaCode = MYCO;
else if (token[0] == 'y')
aaCode = YEAST;
else if (token[0] == 'c')
aaCode = CILIATES;
else
aaCode = METMT;
printf (" Setting code to %s\n", token);
break;
case CMD_INFERSEL_YES:
printf (" Setting inferpossel=yes\n");
inferPoseSel = YES;
break;
case CMD_INFERSEL_NO:
printf (" Setting inferpossel=no\n");
inferPoseSel = NO;
break;
case CMD_INIT_LAG1:
strcpy (lagModel, "user defined");
sscanf (token, "%d", &tempInt);
lagNumber = tempInt;
printf (" Setting user-defined lag of %d\n", lagNumber);
break;
case CMD_INIT_LAG2:
strcpy (lagModel, token);
printf (" Estimating lag\n");
break;
case CMD_SET_LAG_PR1:
strcpy (lagprModel, "fixed");
printf (" Fixing lag\n");
strcpy (lagprModel, "fixed");
break;
case CMD_SET_LAG_PR2:
sscanf (token, "%lf", &tempD);
lagprUni[0] = tempD;
break;
case CMD_SET_LAG_PR3:
sscanf (token, "%lf", &tempD);
if (tempD <= lagprUni[0])
{
printf (" ERROR: Upper bound on uniform must be greater than lower bound\n");
return (ERROR);
}
lagprUni[1] = tempD;
printf (" Uniform (%1.3lf, %1.3lf) prior on lag\n", lagprUni[0], lagprUni[1]);
strcpy (lagprModel, "uniform");
break;
case CMD_SET_LAG_PR4:
sscanf (token, "%lf", &tempD);
if (tempD <= 0.0)
{
printf (" ERROR: Exponential parameter must be greater than 0\n");
return (ERROR);
}
lagprExp = tempD;
printf (" Exponential (%1.3lf) prior on lag\n", lagprExp);
strcpy (lagprModel, "exponential");
break;
case CMD_SET_INFERRATES1:
printf (" Setting inferrates=yes\n");
inferRates = YES;
break;
case CMD_SET_INFERRATES2:
printf (" Setting inferrates=no\n");
inferRates = NO;
break;
case CMD_SET_COVARION1:
printf (" Setting covarion=yes\n");
useCovarion = YES;
break;
case CMD_SET_COVARION2:
printf (" Setting covarion=no\n");
useCovarion = NO;
break;
case CMD_SET_PROPS1:
printf (" Setting %s\n", token);
if (!strcmp("qmatwin", token))
propSet = 0;
else if (!strcmp("pialpha", token))
propSet = 1;
else if (!strcmp("ratewin", token))
propSet = 2;
else if (!strcmp("tuning", token))
propSet = 3;
else if (!strcmp("clocktune", token))
propSet = 4;
else if (!strcmp("timetune", token))
propSet = 5;
else if (!strcmp("mtune", token))
propSet = 6;
else if (!strcmp("extendp", token))
propSet = 7;
else if (!strcmp("wormtune", token))
propSet = 8;
else if (!strcmp("bdwin", token))
propSet = 9;
else if (!strcmp("omegawin", token))
propSet = 10;
else if (!strcmp("rhowin", token))
propSet = 11;
else if (!strcmp("omegaalpha", token))
propSet = 12;
else if (!strcmp("invslide", token))
propSet = 13;
else if (!strcmp("switchwin", token))
propSet = 14;
else if (!strcmp("alphawin", token))
propSet = 15;
else if (!strcmp("reconlim", token))
propSet = 16;
else if (!strcmp("tbrextendp", token))
propSet = 17;
else if (!strcmp("tbrtune", token))
propSet = 18;
else if (!strcmp("bltune", token))
propSet = 19;
break;
case CMD_SET_PROPS2:
sscanf (token, "%lf", &tempD);
if (propSet == 0)
qMatWinProp = tempD;
else if (propSet == 1)
piAlphaProp = tempD;
else if (propSet == 2)
rateWinProp = tempD;
else if (propSet == 3)
tuningProp = tempD;
else if (propSet == 4)
clockTuneProp = tempD;
else if (propSet == 5)
timeTuneProp = tempD;
else if (propSet == 6)
mTuneProp = tempD;
else if (propSet == 7)
extendPProp = tempD;
else if (propSet == 8)
wormTuneProp = tempD;
else if (propSet == 9)
bdWinProp = tempD;
else if (propSet == 10)
omegaWinProp = tempD;
else if (propSet == 11)
rhoWinProp = tempD;
else if (propSet == 12)
omegaAlphaProp = tempD;
else if (propSet == 13)
invSlideProp = tempD;
else if (propSet == 14)
switchWinProp = tempD;
else if (propSet == 15)
alphaWinProp = tempD;
else if (propSet == 16)
reconLimProp = tempD;
else if (propSet == 17)
tbrExtendPProp = tempD;
else if (propSet == 18)
tbrTuneProp = tempD;
else if (propSet == 19)
blTuneProp = tempD;
break;
case CMD_SET_COVTYPE:
strcpy (covarionModelType, token);
printf (" Setting covtype=%s\n", covarionModelType);
break;
case CMD_SET_CODING:
strcpy (codingType, token);
printf (" Setting coding=%s\n", codingType);
break;
case CMD_SET_STATE_PR1:
strcpy (stateFreqPrModel, "fixed");
printf (" State frequencies fixed\n");
break;
case CMD_SET_STATE_PR2:
sscanf (token, "%lf", &tempD);
statefreqprDir = tempD;
strcpy (stateFreqPrModel, "dirichlet");
printf (" State frequencies follow a dirichlet(%lf)\n", tempD);
break;
case CMD_SET_MOVE_PROPS:
printf (" Setting move rates\n\n");
for (;;)
{
printf (" 1: %1.2lf = relative probability of changes to Q matrix\n", moveRates[0]);
printf (" 2: %1.2lf = relative probability of changes to base frequencies\n", moveRates[1]);
printf (" 3: %1.2lf = relative probability of changes to gamma shape\n", moveRates[2]);
printf (" 4: %1.2lf = relative probability of changes to site rates\n", moveRates[3]);
printf (" 5: %1.2lf = relative probability of changes to tree (stochastic NNI)\n", moveRates[4]);
printf (" 6: %1.2lf = relative probability of changes to clock tree\n", moveRates[5]);
printf (" 7: %1.2lf = relative probability of changes to time constrained tree\n", moveRates[6]);
printf (" 8: %1.2lf = relative probability of changes to tree height\n", moveRates[7]);
printf (" 9: %1.2lf = relative probability of changes to tree (one worm)\n", moveRates[8]);
printf (" 10: %1.2lf = relative probability of changes to node time\n", moveRates[9]);
printf (" 11: %1.2lf = relative probability of changes to bd parameters\n", moveRates[10]);
printf (" 12: %1.2lf = relative probability of changes to omega\n", moveRates[11]);
printf (" 13: %1.2lf = relative probability of changes to omega probabilities\n", moveRates[12]);
printf (" 14: %1.2lf = relative probability of changes to auto correlation\n", moveRates[13]);
printf (" 15: %1.2lf = relative probability of changes to lag\n", moveRates[14]);
printf (" 16: %1.2lf = relative probability of changes to tree (stochastic SPR)\n", moveRates[15]);
printf (" 17: %1.2lf = relative probability of changes to proportion invariant\n", moveRates[16]);
printf (" 18: %1.2lf = relative probability of changes to covarion parameter\n", moveRates[17]);
printf (" 19: %1.2lf = relative probability of hanges to tree (TBR1)\n", moveRates[18]);
printf (" 20: %1.2lf = relative probability of changes to GC swith parameters\n", moveRates[19]);
printf (" 21: %1.2lf = relative probability of changes to tree (TBR2)\n", moveRates[20]);
printf (" 22: %1.2lf = relative probability of changes to a branch length\n", moveRates[21]);
printf (" 23: %1.2lf = relative probability of changes to tree (eraser)\n", moveRates[22]);
printf (" 24: %1.2lf = relative probability of changes to tree (biased SPR)\n", moveRates[23]);
printf (" 25: %1.2lf = relative probability of changes to tree (biased TBR)\n", moveRates[24]);
printf ("\n");
printf (" Which move do you wish to change (0 to exit): ");
tempInt = (int)EnterNum ();
if (tempInt == 0)
break;
else if (tempInt < 0 || tempInt > 25)
{
printf (" You must enter a number between 0 and 25\n\n");
}
else
{
printf (" Enter new relative proposal probability: ");
tempD = EnterNum ();
moveRates[tempInt - 1] = tempD;
}
}
break;
case CMD_SET_MCMC_BURN:
sscanf (token, "%d", &tempInt);
mcmcBurn = tempInt;
break;
case CMD_SET_CYCLEFREQ:
sscanf (token, "%d", &tempInt);
cycleFreq = tempInt;
break;
case CMD_SET_CALCPSEUDOBF:
if (!strcmp("yes", token))
calcPseudoBf = YES;
else
calcPseudoBf = NO;
break;
case CMD_SET_PARS_CRIT:
printf (" Setting parsmodel=%s\n", token);
if (!strcmp("yes", token))
useParsCriterion = YES;
else
useParsCriterion = NO;
break;
case CMD_SET_TYPESET1:
//printf ("typset1 (%s)\n", token);
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
break;
case CMD_SET_TYPESET2:
//printf ("typset2 (%s)\n", token);
i = 0;
while (token[i] != '\0')
{
typeDefLabels[nTypeDefs][i] = token[i];
i++;
}
typeDefLabels[nTypeDefs][i] = '|';
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetPotWait = YES;
charSetFreq = 1;
printf (" Assigning typeset set \"");
i = 0;
while (typeDefLabels[nTypeDefs][i] != '|')
{
printf ("%c", typeDefLabels[nTypeDefs][i]);
i++;
}
printf ("\"\n");
if (nTypeDefs > 0)
{
typeDef = (int *)realloc(typeDef, (size_t) ((nTypeDefs+1) * nChar * sizeof(int)));
if (!typeDef)
{
printf (" ERROR: Could not reallocate typeDef\n");
return (ERROR);
}
for (i=nTypeDefs*nChar; i<(nTypeDefs+1)*nChar; i++)
typeDef[i] = UNORDERED;
}
break;
case CMD_SET_TYPESET3:
//printf ("typset3 (%s)\n", token);
printf (" ERROR: You cannot use typeset names that are digits\n");
return (ERROR);
break;
case CMD_SET_TYPESET4:
//printf ("typset4 (%s)\n", token);
if (!strcmp("ord", token))
charOrdering = ORDERED;
else
charOrdering = UNORDERED;
break;
case CMD_SET_TYPESET5:
//printf ("typset5 (%s)\n", token);
break;
case CMD_SET_TYPESET6:
//printf ("typset6 (%s)\n", token);
if (charSetWait == NO && charSetSlashWait == NO && charSetPotWait == NO)
{
j = charSetFreq;
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
if (j % charSetFreq == 0)
typeDef[nTypeDefs*nChar + i] = charOrdering;
j++;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetFreq = 1;
charSetPotWait = YES;
}
sscanf (token, "%d", &tempInt);
if (tempInt <= 0 || tempInt > nChar)
{
printf (" ERROR: Number (%d) out of range\n", tempInt);
return (ERROR);
}
if (charSetSlashWait == YES && charSetWait == YES)
{
printf (" ERROR: Problem assigning character set\n");
return (ERROR);
}
if (charSetSlashWait == YES)
{
charSetFreq = tempInt;
charSetSlashWait = NO;
charSetPotWait = NO;
}
else if (charSetWait == YES)
{
charSetTo = tempInt;
charSetWait = NO;
charSetPotWait = NO;
}
else
{
if (charSetWait == NO)
{
charSetFrom = tempInt;
charSetTo = tempInt;
charSetPotWait = NO;
}
else
{
charSetTo = tempInt;
charSetPotWait = NO;
}
}
break;
case CMD_SET_TYPESET7:
//printf ("typset7 (%s)\n", token);
charSetWait = YES;
charSetPotWait = YES;
break;
case CMD_SET_TYPESET8:
//printf ("typset8 (%s)\n", token);
charSetSlashWait = YES;
charSetPotWait = YES;
break;
case CMD_SET_TYPESET9:
//printf ("typset9 (%s)\n", token);
if (charSetWait == NO && charSetSlashWait == NO && charSetPotWait == NO)
{
j = charSetFreq;
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
if (j % charSetFreq == 0)
typeDef[nTypeDefs*nChar + i] = charOrdering;
j++;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetFreq = 1;
charSetPotWait = YES;
}
/*for (i=0; i<(nTypeDefs+1)*nChar; i++)
{
printf ("%d", typeDef[i]);
}
printf ("\n");*/
nTypeDefs++;
break;
case CMD_SET_TYPESET10:
//printf ("typset10 (%s)\n", token);
foundSet = NO;
for (i=0; i<nCharSets; i++)
{
j = 0;
while (charSetLabels[i][j] != '|')
{
tempString[j] = charSetLabels[i][j];
j++;
}
tempString[j] = '\0';
if (!strcmp(tempString, token))
{
foundSet = YES;
//printf ("match at %s %s\n", token, tempString);
tempInt = (int)pow(2.0, (double)(i+1));
for (j=0; j<nChar; j++)
{
tempInt2 = tempInt & charSet[j];
if (tempInt == tempInt2)
{
typeDef[nTypeDefs*nChar + j] = charOrdering;
//sitePartitions[j] = whichPartition;
}
}
}
}
if (foundSet == NO)
{
printf (" ERROR: Could not find charset %s\n", token);
return (ERROR);
}
break;
case CMD_SET_TYPESET11:
//printf ("typset11 (%s)\n", token);
if (charSetWait == NO && charSetSlashWait == NO && charSetPotWait == NO)
{
j = charSetFreq;
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
if (j % charSetFreq == 0)
typeDef[nTypeDefs*nChar + i] = charOrdering;
j++;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetFreq = 1;
charSetPotWait = YES;
}
break;
case CMD_SET_STATESSET1:
//printf ("typset1 (%s)\n", token);
if (isMatrixAllocated == NO)
{
printf (" ERROR: Data not read in\n");
return (ERROR);
}
break;
case CMD_SET_STATESSET2:
//printf ("typset2 (%s)\n", token);
i = 0;
while (token[i] != '\0')
{
nStatesDefLabels[nNStatesDefs][i] = token[i];
i++;
}
nStatesDefLabels[nNStatesDefs][i] = '|';
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetPotWait = YES;
charSetFreq = 1;
printf (" Assigning nstatesset set \"");
i = 0;
while (nStatesDefLabels[nNStatesDefs][i] != '|')
{
printf ("%c", nStatesDefLabels[nNStatesDefs][i]);
i++;
}
printf ("\"\n");
if (nNStatesDefs > 0)
{
nStatesDef = (int *)realloc(nStatesDef, (size_t) ((nNStatesDefs+1) * nChar * sizeof(int)));
if (!nStatesDef)
{
printf (" ERROR: Could not reallocate nStatesDef\n");
return (ERROR);
}
for (i=nNStatesDefs*nChar; i<(nNStatesDefs+1)*nChar; i++)
nStatesDef[i] = nCharStates;
}
break;
case CMD_SET_STATESSET3:
//printf ("typset3 (%s)\n", token);
printf (" ERROR: You cannot use nstatesset names that are digits\n");
return (ERROR);
break;
case CMD_SET_STATESSET4:
//printf ("typset4 (%s)\n", token);
sscanf (token, "%d", &charOrdering);
break;
case CMD_SET_STATESSET5:
//printf ("typset5 (%s)\n", token);
break;
case CMD_SET_STATESSET6:
//printf ("typset6 (%s)\n", token);
if (charSetWait == NO && charSetSlashWait == NO && charSetPotWait == NO)
{
j = charSetFreq;
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
if (j % charSetFreq == 0)
nStatesDef[nNStatesDefs*nChar + i] = charOrdering;
j++;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetFreq = 1;
charSetPotWait = YES;
}
sscanf (token, "%d", &tempInt);
if (tempInt <= 0 || tempInt > nChar)
{
printf (" ERROR: Number (%d) out of range\n", tempInt);
return (ERROR);
}
if (charSetSlashWait == YES && charSetWait == YES)
{
printf (" ERROR: Problem assigning character set\n");
return (ERROR);
}
if (charSetSlashWait == YES)
{
charSetFreq = tempInt;
charSetSlashWait = NO;
charSetPotWait = NO;
}
else if (charSetWait == YES)
{
charSetTo = tempInt;
charSetWait = NO;
charSetPotWait = NO;
}
else
{
if (charSetWait == NO)
{
charSetFrom = tempInt;
charSetTo = tempInt;
charSetPotWait = NO;
}
else
{
charSetTo = tempInt;
charSetPotWait = NO;
}
}
break;
case CMD_SET_STATESSET7:
//printf ("typset7 (%s)\n", token);
charSetWait = YES;
charSetPotWait = YES;
break;
case CMD_SET_STATESSET8:
//printf ("typset8 (%s)\n", token);
charSetSlashWait = YES;
charSetPotWait = YES;
break;
case CMD_SET_STATESSET9:
//printf ("typset9 (%s)\n", token);
if (charSetWait == NO && charSetSlashWait == NO && charSetPotWait == NO)
{
j = charSetFreq;
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
if (j % charSetFreq == 0)
nStatesDef[nNStatesDefs*nChar + i] = charOrdering;
j++;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetFreq = 1;
charSetPotWait = YES;
}
/*for (i=0; i<(nNStatesDefs+1)*nChar; i++)
{
printf ("%d", nStatesDef[i]);
}
printf ("\n");*/
nNStatesDefs++;
break;
case CMD_SET_STATESSET10:
//printf ("typset10 (%s)\n", token);
foundSet = NO;
for (i=0; i<nCharSets; i++)
{
j = 0;
while (charSetLabels[i][j] != '|')
{
tempString[j] = charSetLabels[i][j];
j++;
}
tempString[j] = '\0';
if (!strcmp(tempString, token))
{
foundSet = YES;
//printf ("match at %s %s\n", token, tempString);
tempInt = (int)pow(2.0, (double)(i+1));
for (j=0; j<nChar; j++)
{
tempInt2 = tempInt & charSet[j];
if (tempInt == tempInt2)
{
nStatesDef[nNStatesDefs*nChar + j] = charOrdering;
//sitePartitions[j] = whichPartition;
}
}
}
}
if (foundSet == NO)
{
printf (" ERROR: Could not find charset %s\n", token);
return (ERROR);
}
break;
case CMD_SET_STATESSET11:
//printf ("typset11 (%s)\n", token);
if (charSetWait == NO && charSetSlashWait == NO && charSetPotWait == NO)
{
j = charSetFreq;
for (i=charSetFrom-1; i<=charSetTo-1; i++)
{
if (j % charSetFreq == 0)
nStatesDef[nNStatesDefs*nChar + i] = charOrdering;
j++;
}
charSetFrom = -1;
charSetTo = -1;
charSetWait = NO;
charSetSlashWait = NO;
charSetFreq = 1;
charSetPotWait = YES;
}
break;
case CMD_SET_ASSUME1:
foundSet = NO;
for (i=0; i<nTypeDefs; i++)
{
j = 0;
while (typeDefLabels[i][j] != '|')
{
tempString[j] = typeDefLabels[i][j];
j++;
}
tempString[j] = '\0';
if (!strcmp(tempString, token))
{
foundSet = YES;
//printf ("match at %s %s\n", token, tempString);
for (j=0; j<nChar; j++)
{
charType[j] = typeDef[i*nChar + j];
}
}
}
if (foundSet == NO)
{
printf (" ERROR: Could not find typeset %s\n", token);
return (ERROR);
}
printf (" Assume typeset = %s\n", token);
break;
case CMD_SET_ASSUME2:
foundSet = NO;
for (i=0; i<nNStatesDefs; i++)
{
j = 0;
while (nStatesDefLabels[i][j] != '|')
{
tempString[j] = nStatesDefLabels[i][j];
j++;
}
tempString[j] = '\0';
if (!strcmp(tempString, token))
{
foundSet = YES;
//printf ("match at %s %s\n", token, tempString);
for (j=0; j<nChar; j++)
{
charNStates[j] = nStatesDef[i*nChar + j];
}
}
}
if (foundSet == NO)
{
printf (" ERROR: Could not find nstatesset %s\n", token);
return (ERROR);
}
printf (" Assume nstatesset = %s\n", token);
break;
}
return (NO_ERROR);
}
double EnterNum (void)
{
double tempD;
char tempString[20];
for (;;)
{
fgets(tempString, 20, stdin);
sscanf (tempString, "%lf", &tempD);
return tempD;
}
}
void ErrorExit (void)
{
if (isMatrixAllocated == YES)
{
free (origDataMatrix);
free (taxonLabels);
free (excludedSites);
free (sitePartitions);
free (matrixCounter);
free (charSet);
free (calibrations);
free (constraints);
free (excludedTaxa);
free (userTree);
free (sumTree);
free (transOldNames);
free (transNewNames);
free (charType);
free (charNStates);
free (typeDef);
free (nStatesDef);
}
nTaxa = nChar = 0;
isMatrixAllocated = NO;
isNtaxaInitialized = NO;
isNcharInitialized = NO;
}
void FinishTree (TreeNode *p, int *i, int isThisTreeRooted)
{
if (p != NULL)
{
FinishTree (p->left, i, isThisTreeRooted);
FinishTree (p->right, i, isThisTreeRooted);
p->marked = NO;
if (p->left == NULL && p->right == NULL && p->anc != NULL)
{
}
else if (p->left != NULL && p->right == NULL && p->anc == NULL)
{
if (isThisTreeRooted == YES)
p->index = (*i)++;
}
else
{
p->index = (*i)++;
}
}
}
#if defined (CONTREE)
int FirstTaxonInPartition (unsigned int *partition, int length)
{
int i, j, nBits, taxon;
unsigned int x;
nBits = sizeof(unsigned int) * 8;
for (i=taxon=0; i<length; i++)
{
x = 1;
for (j=0; j<nBits; j++)
{
if (partition[i]&x)
return taxon;
taxon++;
x <<= 1;
}
}
return taxon;
}
void FlipBits (unsigned int *partition, int length, unsigned int lastMask)
{
int i;
for (i=0; i<length; i++)
partition[i] ^= -1;
partition[i - 1] &= lastMask;
}
void GetConDownPass (PolyNode **downPass, PolyNode *p, int *i)
{
PolyNode *q;
if (p->left != NULL)
{
for (q=p->left; q!=NULL; q=q->sib)
GetConDownPass(downPass, q, i);
}
downPass[(*i)++] = p;
}
#endif
void GetToken (int *tokenType)
{
int allNumbers;
register char *temp;
(*tokenType) = 0;
temp = token;
while (IsWhite(*tokenP) == 1 || IsWhite(*tokenP) == 2)
{
if (IsWhite(*tokenP) == 2)
*tokenType = RETURNSYMBOL;
++tokenP;
}
if (IsIn(*tokenP,"="))
{
*temp++ = *tokenP++;
*tokenType = EQUALSIGN;
}
else if (IsIn(*tokenP,";"))
{
*temp++ = *tokenP++;
*tokenType = SEMICOLON;
}
else if (IsIn(*tokenP,":"))
{
*temp++ = *tokenP++;
*tokenType = COLON;
}
else if (IsIn(*tokenP,","))
{
*temp++ = *tokenP++;
*tokenType = COMMA;
}
else if (IsIn(*tokenP,"#"))
{
*temp++ = *tokenP++;
*tokenType = POUNDSIGN;
}
else if (IsIn(*tokenP,"("))
{
*temp++ = *tokenP++;
*tokenType = LEFTPAR;
}
else if (IsIn(*tokenP,")"))
{
*temp++ = *tokenP++;
*tokenType = RIGHTPAR;
}
else if (IsIn(*tokenP,"["))
{
*temp++ = *tokenP++;
*tokenType = LEFTCOMMENT;
}
else if (IsIn(*tokenP,"]"))
{
*temp++ = *tokenP++;
*tokenType = RIGHTCOMMENT;
}
else if (IsIn(*tokenP,"-"))
{
*temp++ = *tokenP++;
*tokenType = DASH;
}
else if (IsIn(*tokenP,"?"))
{
*temp++ = *tokenP++;
*tokenType = QUESTIONMARK;
}
else if (IsIn(*tokenP,"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789."))
{
allNumbers = TRUE;
if (!IsIn(*tokenP,"0123456789."))
allNumbers = FALSE;
*temp++ = *tokenP++;
while(IsIn(*tokenP,"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789."))
{
if (!IsIn(*tokenP,"0123456789."))
allNumbers = FALSE;
*temp++ = *tokenP++;
}
if (allNumbers == TRUE)
*tokenType = NUMBER;
else
*tokenType = ALPHA;
}
else if (IsIn(*tokenP,"*"))
{
*temp++ = *tokenP++;
*tokenType = ASTERISK;
}
else if (IsIn(*tokenP,"/"))
{
*temp++ = *tokenP++;
*tokenType = BACKSLASH;
}
else if (IsIn(*tokenP,"'\\'"))
{
*temp++ = *tokenP++;
*tokenType = FORWARDSLASH;
}
else if (IsIn(*tokenP,"!"))
{
*temp++ = *tokenP++;
*tokenType = EXCLAMATIONMARK;
}
else if (IsIn(*tokenP,"%"))
{
*temp++ = *tokenP++;
*tokenType = PERCENT;
}
else if (IsIn(*tokenP,"&"))
{
*temp++ = *tokenP++;
*tokenType = AMPERSTAND;
}
else if (IsIn(*tokenP,"~"))
{
*temp++ = *tokenP++;
*tokenType = TILDE;
}
else if (IsIn(*tokenP,"+"))
{
*temp++ = *tokenP++;
*tokenType = PLUS;
}
else if (IsIn(*tokenP,"^"))
{
*temp++ = *tokenP++;
*tokenType = CARAT;
}
else if (IsIn(*tokenP,"$"))
{
*temp++ = *tokenP++;
*tokenType = DOLLARSIGN;
}
else if (IsIn(*tokenP,"@"))
{
*temp++ = *tokenP++;
*tokenType = ATSIGN;
}
else if (IsIn(*tokenP,"|"))
{
*temp++ = *tokenP++;
*tokenType = PIPESIGN;
}
else if (IsIn(*tokenP,"{"))
{
*temp++ = *tokenP++;
*tokenType = LEFTCURLY;
}
else if (IsIn(*tokenP,"}"))
{
*temp++ = *tokenP++;
*tokenType = RIGHTCURLY;
}
*temp = '\0';
}
void GetUserDownPass (TreeNode *p, TreeNode **x, int *y)
{
if (p != NULL)
{
GetUserDownPass (p->left, x, y);
GetUserDownPass (p->right, x, y);
x[(*y)] = p;
(*y)++;
}
}
void GetUserHelp (void)
{
if (generalHelp == YES)
{
printf ("\n Commands that are available include:\n\n");
printf (" execute -- Executes a file\n");
printf (" quit -- Quits the program\n");
printf (" lset -- Sets the parameters of the likelihood\n");
printf (" prset -- Sets the priors for the parameters\n");
printf (" props -- Sets MCMC chain parameters\n");
printf (" mcmc -- Starts Markov chain Monte Carlo\n");
printf (" mcmcp -- Sets the parameters of a chain (without starting analysis)\n");
printf (" exclude -- Excludes sites from the analysis\n");
printf (" include -- Includes sites\n");
printf (" delete -- Deletes taxa from the analysis\n");
printf (" restore -- Restores taxa\n");
printf (" charstat -- Shows status of characters\n");
printf (" charset -- Assigns a group of sites to a set\n");
printf (" partition -- Assigns a character partition\n");
printf (" constraint -- Assigns a constraint on a tree\n");
printf (" calibration -- Assigns a calibration on a tree\n");
printf (" outgroup -- Assigns a single species to be the outgroup\n");
printf (" root -- Roots tree at outgroup species\n");
printf (" deroot -- Deroots tree\n");
printf (" showtree -- Shows the current user tree\n");
printf (" shownodes -- Shows the current user tree as linked nodes\n");
printf (" sumt -- Summarize the trees in a tree file\n");
printf (" set -- Sets run conditions of program\n");
printf (" usertree -- Assigns a user tree\n");
printf ("\n");
}
else
{
if (!strcmp(helpRequest, "execute"))
{
printf ("\n execute\n\n");
printf (" This command executes a file called <file name>.\n");
printf (" The correct usage is: \"execute <file name>\"\n");
printf (" For example, \"execute replicase.nex\" would execute the\n");
printf (" file named \"replicase.nex\". This file must be in the\n");
printf (" same directory as the executable.\n\n");
}
else if (!strcmp(helpRequest, "quit"))
{
printf ("\n quit\n\n");
printf (" This command quits the program.\n");
printf (" The correct usage is: \"quit\"\n\n");
}
else if (!strcmp(helpRequest, "lset"))
{
printf ("\n lset\n\n");
printf (" This command sets the parameters of the likelihood model.\n");
printf (" The likelihood function is the probability of observing the\n");
printf (" data conditional on the phylogenetic model. In order to\n");
printf (" calculate the likelihood, you must assume a model of character\n");
printf (" change. This command lets you tailor these assumptions.\n");
printf (" The correct usage is: \"lset <parameter>=<option>\"\n");
printf (" For example, \"lset nst=6 rates=gamma\" would set the\n");
printf (" model to a general model of DNA substition (the GTR)\n");
printf (" with gamma-distributed rate variation across sites.\n\n");
printf (" Options: \n\n");
printf (" nst -- Sets the number of substitution types: \"1\" is JC69 or \n");
printf (" F81, \"2\" is K80 or HKY85, \"6\" is GTR, and \"12\" is \n");
printf (" the general nonreversible model. \n");
printf (" aamodel -- Sets the model of substitution for amino acid sequence \n");
printf (" data. The options are \"poisson\" (a glorified Jukes- \n");
printf (" Cantor), \"equalin\" (a glorified Felsenstein, 1981), \n");
printf (" \"jones\", \"dayhoff\", and \"gtr\". \n");
printf (" rates -- Sets the model for among-site rate variation: \n");
printf (" * equal -- No rate variation across sites. \n");
printf (" * gamma -- Gamma-distributed rate variation. \n");
printf (" * adgamma -- Autocorrelated rates across sites. The \n");
printf (" marginal rate at a site is gamma, but \n");
printf (" adjacent sites have correlated rates. \n");
printf (" * invariant -- A proportion of the sites are invariable. \n");
printf (" * invgamma -- A proportion of the sites are invariable \n");
printf (" while the rate for the remaining sites is \n");
printf (" drawn from a gamma distribution. \n");
printf (" * sitespec -- Site specific rates where sites are \n");
printf (" assigned to partitions and the rate for \n");
printf (" each partition estimated separately. \n");
printf (" * ssgamma -- Site specific rates but the rates within \n");
printf (" a class have rate variation as described \n");
printf (" by a gamma distribution. \n");
printf (" * ssadgamma -- Site specific rates but the rates within \n");
printf (" a class have rate variation as described \n");
printf (" by a autocorrelated gamma distribution. \n");
printf (" inferrates -- When inferrates=yes, the rate factor of the sites is \n");
printf (" estimated. \n");
printf (" basefreq -- Sets the base frequencies: \"equal\" sets the frequency \n");
printf (" to 1/4 for each nucleotide, \"empirical\" sets the freq- \n");
printf (" uencies to the observed frequency of each nucleotide in \n");
printf (" the alignment, and \"estimate\" allows the program to \n");
printf (" estimate the frequencies. Note that when \"nst=12\", that \n");
printf (" the base frequencies are completely determined by the Q \n");
printf (" matrix. \n");
printf (" clock -- Sets the model for branch length constraints: \"strict\" \n");
printf (" restrains the branch lengths such that the molecular clock\n");
printf (" is obeyed, \"relaxed\" relaxes the molecular clock \n");
printf (" assumption by assuming that rates change on the tree \n");
printf (" according to a compound Poisson process, and \"uncon- \n");
printf (" strained\" allows each branch to have its own rate \n");
printf (" parameter. \n");
printf (" tratio -- Sets the transition/transverion rate ratio. This option \n");
printf (" only works when \"nst=2\". \n");
printf (" revmat -- Sets the rates for the GTR model. This option only works \n");
printf (" when \"nst=6\". \n");
printf (" nonrevmat -- Sets the rates for the general nonreversible model. This \n");
printf (" option only works when \"nst=12\". \n");
printf (" shape -- Sets the shape parameter of the gamma distribution. This \n");
printf (" option only works when gamma-distributed rate variation \n");
printf (" has been selected (\"rates=gamma\"). \n");
printf (" ncat -- Sets the number of rate categories for the gamma distri- \n");
printf (" bution. The gamma distribution is a continuous one. \n");
printf (" However, it is virtually impossible to calculate likeli- \n");
printf (" hoods under the gamma distribution. Hence, an approx- \n");
printf (" imation to the continuous gamma is used; the gamma distri-\n");
printf (" bution is broken into ncat categories of equal weight \n");
printf (" (1/ncat). The mean rate for each category represents the \n");
printf (" rate for the entire category. This option allows you to \n");
printf (" specify how many rates to use when approximating the \n");
printf (" gamma. The approximation is better as ncat is increased. \n");
printf (" In practice, \"ncat=4\" does a reasonable job of approx- \n");
printf (" imating the continuous gamma. \n");
printf (" coding -- This specifies how characters were sampled. If all \n");
printf (" site patterns had the possiblity of being sampled, then \n");
printf (" \"all\" should be specified (the default). Otherwise, \n");
printf (" \"variable\" (only variable characters), \"informative\" \n");
printf (" only parsimony informative), \"noabsence\" (patterns \n");
printf (" with all characters absent), or \"nopresence\" (patterns \n");
printf (" with all characters present) should be specified. These \n");
printf (" options only work with morphological (all/variable/ \n");
printf (" informative) or restriction site (all/variable/noabsence/ \n");
printf (" nopresence) data. \n");
printf (" enforcecodon -- Enforces the use of a 61 X 61 codon model of DNA \n");
printf (" substitution. Use of this option allows you to estimate \n");
printf (" the nonsynonymous/synonymous rate of substitution (omega).\n");
printf (" Make certain that the data are protein coding DNA \n");
printf (" sequences that are in frame (i.e., the length of the \n");
printf (" sequences should be divisable by three. \n");
printf (" code -- Enforces the use of a particular genetic code. The default\n");
printf (" is the universal code. Other options include \"vertmt\" \n");
printf (" for vertebrate mitochondrial DNA, \"mycoplasma\", \n");
printf (" \"yeast\", \"ciliates\", and \"metmt\" (for metazoan \n");
printf (" mitochondrial DNA, except vertebrates). \n");
printf (" omegavar -- Allows the nonsynonymous/synonymous rate ratio (omega) to \n");
printf (" vary across codons according to the model of Nielsen and \n");
printf (" Yang (1998) when the \"ny98\" option is enforced. Other- \n");
printf (" wise, omega is assumed to be equal across sites. \n");
printf (" omegaratio -- Sets the nonsynonymous/synonymous rate ratio. \n");
printf (" seqerror -- Sets the probability of a sequencing error at a site in \n");
printf (" the aligned sequence. \n");
printf (" inferpossel -- Sets the option for inferring positively selected sites. \n");
printf (" You must specify the codon model of DNA substitution and \n");
printf (" the ny98 model for omega variation. \n");
printf (" sitepartition -- Sets the name of the site partition to use for site \n");
printf (" specific rate variation. A partition must be defined for \n");
printf (" this option to be implemented. \n");
printf (" siterates -- Sets the rates for site specific rate variation. A site \n");
printf (" partition must be defined. \n");
printf (" enforcecon -- Enforces constraints, if defined, when \"enforcecon=yes\".\n");
printf (" enforcecal -- Enforces calibrations. \n");
printf (" inferanc -- Causes the states at nodes specified by constraints to be \n");
printf (" inferred. Constraints must be defined for this option to \n");
printf (" work. \n");
printf (" ancfile -- Determines whether all of the ancestral state information \n");
printf (" is printed to files (yes) or only a summary file for each \n");
printf (" constrained node (no). \n\n");
printf (" Parameter Options Current Setting\n");
printf (" ----------------------------------------------------------------\n");
printf (" nst 1/2/6/12 %s\n", subModel);
if (aaModelType == POISSON)
printf (" aamodel poisson/equalin/jones/dayhoff/gtr poisson\n");
else if (aaModelType == EQUALIN)
printf (" aamodel poisson/equalin/jones/dayhoff/gtr equalin\n");
else if (aaModelType == JONES)
printf (" aamodel poisson/equalin/jones/dayhoff/gtr jones\n");
else if (aaModelType == DAYHOFF)
printf (" aamodel poisson/equalin/jones/dayhoff/gtr dayhoff\n");
else if (aaModelType == GTR)
printf (" aamodel poisson/equalin/jones/dayhoff/gtr gtr\n");
printf (" rates equal/gamma/adgamma/invariant/ \n");
printf (" invgamma/sitespec/ssgamma/ \n");
printf (" ssadgamma %s\n", ratesModel);
if (inferRates == YES)
printf (" inferrates yes/no yes\n");
else
printf (" inferrates yes/no no\n");
printf (" basefreq equal/empirical/estimate %s\n", baseFreqModel);
printf (" clock unconstrained/relaxed/strict %s\n", clockModel);
if (tRatioModel[0] == 'e')
printf (" tratio <number>/estimate %s\n", tRatioModel);
else
printf (" tratio <number>/estimate %lf\n", tRatio);
if (revRatesModel[0] == 'e')
printf (" revmat (<number>, ..., <number>)/estimate %s\n", revRatesModel);
else
printf (" revmat (<number>, ..., <number>)/estimate (%1.2lf,%1.2lf,%1.2lf,%1.2lf,%1.2lf,%1.2lf)\n",
revRates[0], revRates[1], revRates[2], revRates[3], revRates[4], revRates[5]);
if (nonRevRatesModel[0] == 'e')
printf (" nonrevmat (<number>, ..., <number>)/estimate %s\n", nonRevRatesModel);
else
{
printf (" nonrevmat (<number>, ..., <number>)/estimate (%1.2lf,%1.2lf,%1.2lf,%1.2lf,%1.2lf,%1.2lf,\n",
nonRevRates[0], nonRevRates[1], nonRevRates[2], nonRevRates[3], nonRevRates[4], nonRevRates[5]);
printf (" %1.2lf,%1.2lf,%1.2lf,%1.2lf,%1.2lf,%1.2lf)\n",
nonRevRates[6], nonRevRates[7], nonRevRates[8], nonRevRates[9], nonRevRates[10], nonRevRates[11]);
}
if (omegaRatioModel[0] == 'e')
printf (" omega <number>/estimate %s\n", omegaRatioModel);
else
printf (" omega <number>/estimate %lf\n", omegaRatio);
printf (" omegavar equal/ny98 %s\n", codonModelType);
if (shapeModel[0] == 'e')
printf (" shape <number>/estimate %s\n", shapeModel);
else
printf (" shape <number>/estimate %lf\n", shape);
printf (" ncat <number> %d\n", nRateCats);
printf (" coding all/variable/informative/ \n");
printf (" noabsence/nopresence %s\n", codingType);
printf (" seqerror <number> %1.3lf\n", seqErrorProb);
printf (" sitepartition <name> %s\n", partitionName);
printf (" siterates (<number>, ..., <number>)/estimate %s\n", siteRatesModel);
if (enforceConstraints == YES)
printf (" enforcecon yes/no yes\n");
else
printf (" enforcecon yes/no no\n");
if (enforceCalibrations == YES)
printf (" enforcecal yes/no yes\n");
else
printf (" enforcecal yes/no no\n");
if (inferAncStates == YES)
printf (" inferanc yes/no yes\n");
else
printf (" inferanc yes/no no\n");
if (saveAncFiles == YES)
printf (" ancfile yes/no yes\n");
else
printf (" ancfile yes/no no\n");
if (enforceCodonModel == YES)
printf (" enforcecodon yes/no yes\n");
else
printf (" enforcecodon yes/no no\n");
if (inferPoseSel == YES)
printf (" inferpossel yes/no yes\n");
else
printf (" inferpossel yes/no no\n");
printf (" code universal/vertmt/mycoplasma/ \n");
if (aaCode == UNIV)
printf (" yeast/ciliates/metmt universal\n\n");
else if (aaCode == VERTMT)
printf (" yeast/ciliates/metmt vertmt\n\n");
else if (aaCode == MYCO)
printf (" yeast/ciliates/metmt mycoplasma\n\n");
else if (aaCode == YEAST)
printf (" yeast/ciliates/metmt yeast\n\n");
else if (aaCode == CILIATES)
printf (" yeast/ciliates/metmt ciliates\n\n");
else
printf (" yeast/ciliates/metmt metmt\n\n");
}
else if (!strcmp(helpRequest, "exclude"))
{
printf ("\n exclude\n\n");
printf (" This command excludes characters from the analysis.\n");
printf (" The correct usage is: \"exclude <number> <number> <number> - <number>\"\n");
printf (" For example, \"exclude 2 3 10-14 22\" excludes sites 2, 3, 10, 11, 12,\n");
printf (" 13, 14, and 22 from the analysis. Similarly, \"exclude all\" excludes all of\n");
printf (" the characters.\n\n");
}
else if (!strcmp(helpRequest, "include"))
{
printf ("\n include\n\n");
printf (" This command includes characters that were previously deleted from \n");
printf (" the analysis. The correct usage is: \"include <number> <number> \n");
printf (" <number> - <number>\". For example, \"include 2 3 10-14 22\" includes \n");
printf (" sites 2, 3, 10, 11, 12, 13, 14, and 22 in the analysis. Similarly, \n");
printf (" \"include all\" includes all of the characters.\n\n");
}
else if (!strcmp(helpRequest, "delete"))
{
printf ("\n delete\n\n");
printf (" This command deletes taxa from the analysis.\n");
printf (" The correct usage is: \"delete <name> <number>\". A list of the\n");
printf (" taxon names and/or numbers can be used (the taxa are numbered \n");
printf (" from 1 to n in the order in the matrix). For example, \"delete 1 2\n");
printf (" Homo_sapiens\" deletes taxa 1, 2, and the taxon labelled \"Homo sapiens\"\n");
printf (" from the analysis.\n\n");
}
else if (!strcmp(helpRequest, "restore"))
{
printf ("\n restore\n\n");
printf (" This command restores taxa to the analysis.\n");
printf (" The correct usage is: \"restore <name> <number>\". A list of the\n");
printf (" taxon names and/or numbers can be used (the taxa are numbered \n");
printf (" from 1 to n in the order in the matrix). For example, \"restore 1 2\n");
printf (" Homo_sapiens\" restores taxa 1, 2, and the taxon labelled \"Homo sapiens\"\n");
printf (" to the analysis.\n\n");
}
else if (!strcmp(helpRequest, "charstat"))
{
printf ("\n charstat\n\n");
printf (" This command shows the status of all the characters.\n");
printf (" The correct usage is: \"charstat\"\n");
printf (" After typing \"charstat\", the character number, whether it is\n");
printf (" excluded or included, and the partition identity are shown.\n\n");
}
else if (!strcmp(helpRequest, "outgroup"))
{
printf ("\n outgroup\n\n");
printf (" This command assigns a taxon to the outgroup.\n");
printf (" The correct usage is: \"outgroup <number>/<taxon name>\"\n");
printf (" For example, \"outgroup 3\" assigns the third taxon in the\n");
printf (" matrix to be the outgroup. Similarly, \"outgroup Homo_sapiens\".\n");
printf (" assigns the taxon labelled \"Homo_sapiens\" to be the outgroup\n");
printf (" (assuming that there is a taxon named \"Homo_sapiens\" in the matrix).\n");
printf (" Only a single taxon can be assigned to be the outgroup.\n\n");
}
else if (!strcmp(helpRequest, "prset"))
{
printf ("\n prset\n\n");
printf (" This command sets the priors for the phylogenetic model.\n");
printf (" Remember that in a Bayesian analysis, you must specify a\n");
printf (" prior probability distribution for the parameters of the\n");
printf (" likelihood model. In this case, you must specify the priors\n");
printf (" for the model of DNA substitution. qmatpr sets the prior for the\n");
printf (" rate matrix; the options are \"fixed\", \"exp\", and \"uni\", which\n");
printf (" fixes the rate matrix, places an exponential or uniform distribution on\n");
printf (" the rate matrix, respectively. Other options include \"basefreqpr\",\n");
printf (" \"brlenpr\", \"shapepr\", and \"siteratepr\" which specify the prior\n");
printf (" for the base frequencies, branch lengths, gamma shape parameter, or\n");
printf (" site specific rates, respectively. The correct usage is: \"prset \n");
printf (" qmatpr=uni(0,100.0) basefreqpr=dir(1.0)\", which would set the\n");
printf (" prior on the rates of the instantaneous rate matrix to a uniform\n");
printf (" (0,100) and the prior on the base frequencies to a dirichlet.\n\n");
printf (" Options: \n\n");
printf (" Parameter Options Current Setting\n");
printf (" ------------------------------------------------\n");
printf (" qmatpr fixed/exp/uni %s\n", qmatprModel);
printf (" basefreqpr fixed/dir %s\n", basefreqprModel);
printf (" brlenpr uni/exp/bd %s\n", brlenprModel);
printf (" shapepr fixed/exp/uni %s\n", shapeprModel);
printf (" omegapr fixed/exp/uni %s\n", omegaprModel);
printf (" siteratepr fixed/exp/uni %s\n", siterateprModel);
printf (" statefreqpr fixed/dir %s\n\n", stateFreqPrModel);
}
else if (!strcmp(helpRequest, "mcmc"))
{
printf ("\n mcmc\n\n");
printf (" This command starts the Markov chain Monte Carlo (MCMC) analysis.\n");
printf (" The posterior probability of phylogenetic trees (and other parameters\n");
printf (" of the substitution model) cannot be determined analytically. Instead,\n");
printf (" MCMC is used to approximate the posterior probabilities of trees by\n");
printf (" drawing (dependent) samples from the posterior distribution. This\n");
printf (" program can implement a variant of MCMC called \"Metropolis-coupled\n");
printf (" Markov chain Monte Carlo\", or MCMCMC for short. Basically, \"nchains\"\n");
printf (" are run, with nchains - 1 of them heated. The chains are labelled\n");
printf (" 1, 2, ..., nchains. The heat that is applied to the i-th chain is\n");
printf (" B = 1 / (1 + temp X i). B is the power to which the posterior\n");
printf (" probability is raised. When B = 0, all trees have equal probability\n");
printf (" and the chain freely visits trees. B = 1 is the \"cold\" chain (or\n");
printf (" the distribution of interest). MCMCMC can mix better than ordinary\n");
printf (" MCMC; after all of the chains have gone through one cycle, two\n");
printf (" chains are chosen at random and an attempt is made to swap the\n");
printf (" states (with the probability of a swap being determined by\n");
printf (" the Metropolis et al. equation). This allows the chain to potentially\n");
printf (" jump a valley in a single bound. The correct usage is \"mcmc ngen=100000\n");
printf (" nchains=4 temp=0.5\", which performs a MCMCMC analysis with four chains\n");
printf (" with the temperature set to 0.5. The chains would be run for 100,000 cycles.\n\n");
printf (" Options: \n\n");
printf (" Parameter Options Current Setting\n");
printf (" ----------------------------------------------\n");
printf (" seed <number> %ld\n", randomSeed);
printf (" ngen <number> %d\n", nGen);
printf (" samplefreq <number> %d\n", sampleFreq);
printf (" printfreq <number> %d\n", printFreq);
printf (" nchains <number> %d\n", numChains);
printf (" temp <number> %lf\n", chainTemp);
printf (" filename <file name> %s\n", outFile);
printf (" burnin <number> %d\n", mcmcBurn);
/*if (calcPseudoBf == YES)
printf (" calcpseudobf yes/no yes\n");
else
printf (" calcpseudobf yes/no no\n");
printf (" cyclefreq <number> %d\n", cycleFreq);*/
printf (" startingtree random/user %s\n", startingTreeModel);
printf (" nperts <number> %d\n", nPerturbations);
if (saveBrlens == YES)
printf (" savebrlens yes/no yes\n\n");
else
printf (" savebrlens yes/no no\n\n");
}
else if (!strcmp(helpRequest, "mcmcp"))
{
printf ("\n mcmcp\n\n");
printf (" This command sets the parameters of the Markov chain Monte Carlo (MCMC) \n");
printf (" analysis without actually starting the chain. This command is identical\n");
printf (" in all respects to mcmc, except that the analysis will not start after\n");
printf (" this command is issued.\n\n");
printf (" Options: \n\n");
printf (" Parameter Options Current Setting\n");
printf (" ----------------------------------------------\n");
printf (" seed <number> %ld\n", randomSeed);
printf (" ngen <number> %d\n", nGen);
printf (" samplefreq <number> %d\n", sampleFreq);
printf (" printfreq <number> %d\n", printFreq);
printf (" nchains <number> %d\n", numChains);
printf (" temp <number> %lf\n", chainTemp);
printf (" filename <file name> %s\n", outFile);
printf (" burnin <number> %d\n", mcmcBurn);
/*if (calcPseudoBf == YES)
printf (" calcpseudobf yes/no yes\n");
else
printf (" calcpseudobf yes/no no\n");
printf (" cyclefreq <number> %d\n", cycleFreq);*/
printf (" startingtree random/user %s\n", startingTreeModel);
printf (" nperts <number> %d\n", nPerturbations);
if (saveBrlens == YES)
printf (" savebrlens yes/no yes\n\n");
else
printf (" savebrlens yes/no no\n\n");
}
else if (!strcmp(helpRequest, "root"))
{
printf ("\n root\n\n");
printf (" This command roots the tree. If the tree is already\n");
printf (" rooted, a warning is issued. The tree is rooted at\n");
printf (" the outgroup species. The correct usage is \"root\".\n\n");
}
else if (!strcmp(helpRequest, "set"))
{
printf ("\n set\n\n");
printf (" This command sets run conditions of the program. Currently, the only\n");
printf (" option is \"autoclose\". When autoclose=yes, the program will skip\n");
printf (" the querry usually issued at the end of a MCMC analysis.\n\n");
printf (" Options: \n\n");
printf (" Parameter Options Current Setting\n");
printf (" ----------------------------------------------\n");
if (autoclose == YES)
printf (" autoclose yes/no yes\n\n");
else
printf (" autoclose yes/no no\n\n");
}
else if (!strcmp(helpRequest, "charset"))
{
printf ("\n charset\n\n");
printf (" This command defines a character set. The format for the\n");
printf (" charset command is \"charset <name> = <character numbers>\". For \n");
printf (" example, \"charset first_pos = 1-720\\3\" defines a character set \n");
printf (" called \"first_pos\" that includes every third site from 1 to 720. \n");
printf (" The character set name cannot have any spaces in it. The slash (\\) \n");
printf (" is a nifty way of telling the program to assign every third (or \n");
printf (" second, or fifth, or whatever) character to the character set. \n");
printf (" You can assign up to 32 character sets. This option is best used \n");
printf (" not from the command line but rather as a line in the mrbayes block \n");
printf (" of a file. \n\n");
}
else if (!strcmp(helpRequest, "constraint"))
{
printf ("\n constraint\n\n");
printf (" This command defines a tree constraint. The format for the\n");
printf (" constraint command is \"constraint <name> = <list of taxa>\". For \n");
printf (" example, \"constraint apes = human chimp gorilla organg gibbon\" \n");
printf (" defines a constraint consisting of five species. The list of taxa\n");
printf (" defines a constraint on a tree by specifying a taxon bipartition \n");
printf (" that must be present in all trees considered by the MCMC algorithm. \n");
printf (" In effect, by using a constraint, you are specifying a very strong\n");
printf (" prior on the topology of the tree (the posterior probabilities of all\n");
printf (" trees that do not contain the taxon bipartition is zero). For the program\n");
printf (" to actually see a constraint, you must specify enforcecon=yes in the lset\n");
printf (" command. This option is best used as as a line in the mrbayes block.\n\n");
}
else if (!strcmp(helpRequest, "calibration"))
{
printf ("\n calibration\n\n");
printf (" This command defines a calibration on a tree. The format for the\n");
printf (" calibration command is \"calibration <name> = (<min age> <+error>)\n");
printf (" <list of taxa>\". For example, \"calibration apes = (4, 2) human chimp \n");
printf (" gorilla organg gibbon\" defines a calibration consisting of five species. \n");
printf (" The list of taxa defines a constraint on a tree (see description of \n");
printf (" constraint command). The numbers in the parantheses specify two things: \n");
printf (" the first number specifies the youngest age for the clade containing\n");
printf (" the listed taxa; the second number specifies how much older than this\n");
printf (" minimum age the clade can be. The program assumes that the divergence\n");
printf (" time is uniformly distributed on the interval (x, x+y), where x is the\n");
printf (" first number and y is the second number specified in the parantheses.\n");
printf (" In order for the program to see calibrations, you must specify \n");
printf (" enforcecal=yes in the lset command. If you are interested in inferring \n");
printf (" speciation times on a tree (as I suspect you must be if you go through \n");
printf (" the trouble of specifying a calibration), then you should also make certain \n");
printf (" that you assume the molecular clock (or a relaxed version thereof). \n");
printf (" Although you can specify a calibration from the command line, it makes\n");
printf (" more sense to use this option as a line in the mrbayes block. \n\n");
}
else if (!strcmp(helpRequest, "usertree"))
{
printf ("\n usertree\n\n");
printf (" This command allows you to specify a user tree. The user tree can then be\n");
printf (" used as a starting tree for a MCMC analysis. The format for the command is\n");
printf (" \"usertree = <tree in Newick format>\". For example, \"usertree = (A,B,(C,D))\"\n");
printf (" specifies an unrooted tree of four species. Note that the program requires\n");
printf (" that trees are binary (i.e., strictly bifurcating). Hence, there can be only\n");
printf (" one three-way split, as shown in the example. If the tree is not binary, the\n");
printf (" program should return an error.\n\n");
}
else if (!strcmp(helpRequest, "partition"))
{
printf ("\n partition\n\n");
printf (" This command allows you to specify a character partition. The format for \n");
printf (" this command is \"partition <name> = <number of partitions>:<sites in first>,\n");
printf (" <sites in second>,<sites in third>,<sites in fourth>, ...,<sites in last \n");
printf (" partition>\". For example, \"partition by_codon = 3:1st_pos,2nd_pos,3rd_pos\" \n");
printf (" specifies a partition called \"by_codon\" which consists of three parts \n");
printf (" (first, second, and third codon positions). Here, I am assuming that the \n");
printf (" sites in each partition were defined using the charset command. You can \n");
printf (" specify a partition without using charset as follows: \"partition by_codon \n");
printf (" = 3:1 4 6 9 12,2 5 7 10 13,3 6 8 11 14\". However, I recommend that you use \n");
printf (" the charsets to define a set of characters and then use these predefined sets \n");
printf (" when defining the partition. Also, it makes more sense to define a partition\n");
printf (" as a line in the mrbayes block than to issue the command from the command \n");
printf (" line (then again, you may be a masochist, and want to do extra work).\n\n");
}
else if (!strcmp(helpRequest, "cladists"))
{
printf ("\n cladists\n\n");
printf (" Unfortunately, cladists are beyond my ability to help. I suspect that\n");
printf (" you cannot help them either.\n\n");
}
else if (!strcmp(helpRequest, "ken"))
{
printf ("\n ken\n\n");
printf (" mcmc savebrlens=no is the default.\n\n");
}
else if (!strcmp(helpRequest, "props"))
{
printf ("\n props\n\n");
printf (" This command allows you to control aspects of the MCMC algorithm.\n");
printf (" The MCMC algorithm updates parameters in blocks. Each proposal\n");
printf (" mechanism changes the parameter in a specific manner. This command\n");
printf (" lets you change these proposal mechanisms so that the chain mixes\n");
printf (" better for your specific data set. You should only be using this\n");
printf (" command if you have a fairly good understanding of the MCMC algorithm.\n\n");
printf (" Options: \n\n");
printf (" Parameter Current Setting \n");
printf (" ----------------------------------------------\n");
printf (" qmatwin %1.3lf \n", qMatWinProp);
printf (" pialpha %1.3lf \n", piAlphaProp);
printf (" ratewin %1.3lf \n", rateWinProp);
printf (" tuning %1.3lf \n", tuningProp);
printf (" clocktune %1.3lf \n", clockTuneProp);
printf (" timetune %1.3lf \n", timeTuneProp);
printf (" mtune %1.3lf \n", mTuneProp);
printf (" extendp %1.3lf \n", extendPProp);
printf (" wormtune %1.3lf \n", wormTuneProp);
printf (" bdwin %1.3lf \n", bdWinProp);
printf (" omegawin %1.3lf \n", omegaWinProp);
printf (" rhowin %1.3lf \n", rhoWinProp);
printf (" omegaalpha %1.3lf \n", omegaAlphaProp);
printf (" invslide %1.3lf \n", invSlideProp);
printf (" switchwin %1.3lf \n", switchWinProp);
printf (" alphawin %1.3lf \n", alphaWinProp);
printf (" reconlim %1.0lf \n", reconLimProp);
printf (" tbrextendp %1.3lf \n", tbrExtendPProp);
printf (" tbrtune %1.3lf \n", tbrTuneProp);
printf (" blTune %1.3lf \n", blTuneProp);
/*printf (" node time window %lf \n", nodeTimeTuneProp);*/
}
else if (!strcmp(helpRequest, "deroot"))
{
printf ("\n deroot\n\n");
printf (" This command deroots the tree. If the tree is already\n");
printf (" unrooted, a warning is issued. The correct usage is \"deroot\".\n\n");
}
else if (!strcmp(helpRequest, "showtree"))
{
printf ("\n showtree\n\n");
printf (" This command shows the current user tree.\n");
printf (" The correct usage is \"showtree\".\n\n");
}
else if (!strcmp(helpRequest, "shownodes"))
{
printf ("\n shownodes\n\n");
printf (" This command shows the current user tree as a linked list\n");
printf (" of nodes. The nodes are formated as \"N w (l=x r=y a=z) <number>\", \n");
printf (" where \"w\" is the node number, \"x\" is the node to the left,\n");
printf (" \"y\" is the node to the right, and \"z\" is the ancestral node to node\n");
printf (" \"w\", respectively. The last decimal number is the length of the\n");
printf (" branch leading to node \"w\". A \"-1\" indicates that the node does\n");
printf (" not exist (is null). The correct usage is \"shownodes\".\n\n");
}
else if (!strcmp(helpRequest, "sumt"))
{
printf ("\n sumt\n\n");
printf (" This command summarizes the trees in a tree file named \"filename\".\n");
printf (" All of the trees are read from the file and the proportion of the\n");
printf (" time any single taxon bipartition is found is counted. The proportion\n");
printf (" of the time that the bipartition is found is an approximation of\n");
printf (" the posterior probability of the bipartition. (Remember that a\n");
printf (" taxon bipartition is defined by removing a branch on the tree, dividing\n");
printf (" the tree into those taxa to the left and right of the removed branch.\n");
printf (" This set is called a taxon bipartition). The branch length of the\n");
printf (" bipartition is also recorded. The result is a list of the taxon\n");
printf (" bipartitions found, the frequency with which they were found, the\n");
printf (" posterior probability of the bipartition and, if branch lengths were\n");
printf (" recorded, the mean and variance of the length of the branch. The\n");
printf (" partition information is output to a file called \"<filename>.parts\". A\n");
printf (" consensus tree is also printed to a file called \"<filename>.con\".\n");
printf (" The consensus tree is either a 50 percent majority rule tree or a\n");
printf (" majority rule tree with all compatible partitions displayed.\n");
printf (" Finally, the number of trees in the tree file that are skipped is\n");
printf (" controlled by the \"burnin\". The default is 0, but you may want\n");
printf (" to discard those trees that were sampled while the chain was not\n");
printf (" at stationarity. You can display the majority rule consensus tree\n");
printf (" using a program such as PAUP*. You will have to manually put the\n");
printf (" probabilities of clades on the tree.\n\n");
printf (" Options: \n\n");
printf (" Parameter Options Current Setting\n");
printf (" ----------------------------------------------------\n");
printf (" filename <name> %s\n", sumTreeFile);
printf (" burnin <number> %d\n", burnIn);
if (consensusType == HALF_COMPAT)
printf (" contype halfcompat/allcompat halfcompat\n\n");
else
printf (" contype halfcompat/allcompat allcompat\n\n");
}
else if (!strcmp(helpRequest, "sump"))
{
printf ("\n sump\n\n");
printf (" This command summarizes the information in a file named \"filename\".\n");
printf (" The program prints three files during a MCMC analysis: one tree file and\n");
printf (" two parameter files. The parameter files have extensions .p and .bp.\n");
printf (" This command, sump, summarizes the information in the file <filename.bp>.\n");
printf (" The output is to the screen, and provides the mean, variance, and\n");
printf (" 95 percent credible interval for the parameter. You may want to\n");
printf (" discard a specified number of observations from the chain as the\n");
printf (" burn-in.\n\n");
printf (" Options: \n\n");
printf (" Parameter Options Current Setting\n");
printf (" ----------------------------------------------------\n");
printf (" filename <name> %s\n", sumParmFile);
printf (" burnin <number> %d\n\n", burnIn);
}
else if (!strcmp(helpRequest, "andrea"))
{
printf ("\n andrea\n\n");
printf (" Unfortunately, helping Andrea is beyond my ability.\n\n");
}
else
{
printf ("\n Sorry, but I don't recognize the command \"%s\" that you\n", helpRequest);
printf (" requested help with.\n\n");
}
}
}
int IsCommandValid (int commandNumber)
{
int i, stopLoop;
command_list *p, *q;
p = q = cmdPtr;
//printf ("cmdPtr = %d\n", p->index);
if (cmdPtr->left != NULL)
{
p = cmdPtr->left;
q = cmdPtr->left;
}
else
{
if (cmdPtr->rNde != NULL)
cmdPtr = cmdPtr->rNde;
else
{
printf ("next is null \n");
return -1;
}
p = cmdPtr->left;
q = cmdPtr->left;
}
//printf (" p = %d\n", p->index);
/* get expected commands */
for (i=0; i<HIERARCHYSIZE; i++)
expectedCommands[i] = -1;
i = 0;
stopLoop = FALSE;
while (stopLoop == FALSE)
{
if (q->cmd != NUMCOMMANDS + SEMICOLON && !(q->cmdName[0] == 'e' && q->cmdName[1] == 'n' && q->cmdName[2] == 'd'))
expectedCommands[i++] = q->index;
if (q->sib != NULL)
q = q->sib;
else
stopLoop = TRUE;
}
stopLoop = FALSE;
while (stopLoop == FALSE)
{
if (commandNumber == p->cmd)
{
cmdPtr = p;
//printf (" now at %d (%s) (%d %d)\n", p->index, p->cmdName, commandNumber, p->cmd);
return (p->action);
}
else if (p->cmd == NUMCOMMANDS + ANYTOKEN && commandNumber != NUMCOMMANDS + SEMICOLON)
{
cmdPtr = p;
//printf (" *now at %d (%s) (%d %d)\n", p->index, p->cmdName, commandNumber, p->cmd);
return (p->action);
}
else
{
if (p->sib != NULL)
p = p->sib;
else
{
stopLoop = TRUE;
}
/*printf (" p = %d\n", p->index);*/
}
}
return (ERROR_ACTION);
}
#if defined (CONTREE)
int IsPartCompatible (unsigned int *smaller, unsigned int *larger, int length)
{
int i;
for (i=0; i<length; i++)
if ((smaller[i]&larger[i]) != 0)
break;
if (i != length) // potentially incompatible
{
for (i=0; i<length; i++)
if ((smaller[i]|larger[i]) != larger[i])
break;
}
if (i == length) // passed either one of the tests
return 1;
else
return 0;
}
int IsPartNested (unsigned int *smaller, unsigned int *larger, int length)
{
int i;
for (i=0; i<length; i++)
if ((smaller[i]|larger[i]) != larger[i])
break;
if (i == length)
return 1;
else
return 0;
}
#endif
int IsIn (char ch, char *s)
{
while (*s)
{
if (*s++ == ch)
return 1;
}
return 0;
}
int IsWhite (char c)
{
if (c == ' ' || c == '\t' || c == '\n')
{
if (c == '\n')
return 2;
return 1;
}
return 0;
}
int NucID (char nuc)
{
char n;
if (nuc == 'U' || nuc == 'u')
n = 'T';
else
n = nuc;
if (n == 'A' || n == 'a')
{
return 1;
}
else if (n == 'C' || n == 'c')
{
return 2;
}
else if (n == 'G' || n == 'g')
{
return 4;
}
else if (n == 'T' || n == 't')
{
return 8;
}
else if (n == 'R' || n == 'r')
{
return 5;
}
else if (n == 'Y' || n == 'y')
{
return 10;
}
else if (n == 'M' || n == 'm')
{
return 3;
}
else if (n == 'K' || n == 'k')
{
return 12;
}
else if (n == 'S' || n == 's')
{
return 6;
}
else if (n == 'W' || n == 'w')
{
return 9;
}
else if (n == 'H' || n == 'h')
{
return 11;
}
else if (n == 'B' || n == 'b')
{
return 14;
}
else if (n == 'V' || n == 'v')
{
return 7;
}
else if (n == 'D' || n == 'd')
{
return 13;
}
else if (n == 'N' || n == 'n')
{
return 15;
}
else if (n == gapChar)
{
return 15;
}
else if (n == missingChar)
{
return 15;
}
else
return -1;
}
void ParseCommand (char *s)
{
int i, rc, tokenType, commandNumber, actionType, inError, isCommented;
command_list *q;
tokenP = &s[0];
cmdPtr = &cmdList[41];
isCommented = NO;
inError = NO;
changeToLower = YES;
do
{
GetToken (&tokenType);
commandNumber = ParseToken (tokenType);
if (commandNumber == NUMCOMMANDS + LEFTCOMMENT)
isCommented = YES;
if (*token && isCommented == NO)
{
//printf (" token = %s (%d %d)\n", token, tokenType, commandNumber);
actionType = IsCommandValid (commandNumber);
//printf ("actionType = %d\n", actionType);
if (actionType == ERROR_ACTION)
{
//printf ("\n");
inError = YES;
if (tokenType != SEMICOLON)
printf (" ERROR: Invalid command \"%s\"\n", token);
if (expectedCommands[0] != -1)
{
printf (" EXPECTING: ");
i = 0;
while (expectedCommands[i] != -1)
{
q = &cmdList[expectedCommands[i]];
printf ("\"%s\"", q->cmdName);
i++;
if (expectedCommands[i+1] == -1 && expectedCommands[i] != -1)
printf (", or ");
else if (expectedCommands[i] != -1)
printf (", ");
if (i % 4 == 0)
printf ("\n ");
}
//printf ("\n");
}
printf ("\n");
}
else if (actionType >= 0)
{
rc = DoAction (actionType);
if (rc == ERROR)
goto errorExit;
}
}
if (commandNumber == NUMCOMMANDS + RIGHTCOMMENT)
isCommented = NO;
} while (*token && inError == NO);
errorExit:
;
}
int ParseToken (int tokenType)
{
int i;
char tempToken[NUMTOKENCHARS];
PrepareToken ();
for (i=0; i<NUMCOMMANDS; i++)
{
ReadInTempToken (tempToken, i);
if (!strcmp (token, tempToken))
return (i);
}
return (tokenType+NUMCOMMANDS);
}
void PrepareToken (void)
{
int j;
char temp1;
j = 0;
while (token[j] != '\0')
{
temp1 = token[j];
if (changeToLower == YES)
token[j] = ChangeCase (temp1);
else
token[j] = temp1;
j++;
}
}
int ProtID (char aa)
{
if (aa == 'A' || aa == 'a') /* Ala */
{
return 1;
}
else if (aa == 'R' || aa == 'r') /* Arg */
{
return 2;
}
else if (aa == 'N' || aa == 'n') /* Asn */
{
return 3;
}
else if (aa == 'D' || aa == 'd') /* Asp */
{
return 4;
}
else if (aa == 'C' || aa == 'c') /* Cys */
{
return 5;
}
else if (aa == 'Q' || aa == 'q') /* Gln */
{
return 6;
}
else if (aa == 'E' || aa == 'e') /* Glu */
{
return 7;
}
else if (aa == 'G' || aa == 'g') /* Gly */
{
return 8;
}
else if (aa == 'H' || aa == 'h') /* His */
{
return 9;
}
else if (aa == 'I' || aa == 'i') /* Ile */
{
return 10;
}
else if (aa == 'L' || aa == 'l') /* Leu */
{
return 11;
}
else if (aa == 'K' || aa == 'k') /* Lys */
{
return 12;
}
else if (aa == 'M' || aa == 'm') /* Met */
{
return 13;
}
else if (aa == 'F' || aa == 'f') /* Phe */
{
return 14;
}
else if (aa == 'P' || aa == 'p') /* Pro */
{
return 15;
}
else if (aa == 'S' || aa == 's') /* Ser */
{
return 16;
}
else if (aa == 'T' || aa == 't') /* Thr */
{
return 17;
}
else if (aa == 'W' || aa == 'w') /* Trp */
{
return 18;
}
else if (aa == 'Y' || aa == 'y') /* Tyr */
{
return 19;
}
else if (aa == 'V' || aa == 'v') /* Val */
{
return 20;
}
else if (aa == gapChar)
{
return 21;
}
else if (aa == missingChar)
{
return 21;
}
else
return -1;
}
void ReadInTempToken (char tempToken[NUMTOKENCHARS], int i)
{
int j;
for (j=0; j<NUMTOKENCHARS; j++)
tempToken[j] = validTokens[i][j];
tempToken[j] = '\0';
}
int ReadNexusFile (void)
{
int i, rc, tokenType, commandNumber, actionType, inError, isCommented;
char s[STRING_LENGTH];
command_list *q;
FILE *fp, *fopen();
rc = NO_ERROR;
if ((fp = fopen (inFile, "r")) == NULL)
{
printf ("\n ERROR: Could not open file \"%s\"\n\n", inFile);
return ERROR;
}
cmdPtr = &cmdList[0];
isCommented = NO;
inError = NO;
lineNumber = 0;
while (fgets (s, STRING_LENGTH, fp) != NULL)
{
lineNumber++;
//printf ("%s", s);
tokenP = &s[0];
do
{
GetToken (&tokenType);
if (tokenType == RETURNSYMBOL)
returnEncountered = YES;
commandNumber = ParseToken (tokenType);
if (commandNumber == NUMCOMMANDS + LEFTCOMMENT)
isCommented = YES;
if (*token && isCommented == NO)
{
//printf (" token = %s (%d %d)\n", token, tokenType, commandNumber);
actionType = IsCommandValid (commandNumber);
//printf (" actionType = %d\n", actionType);
if (actionType == ERROR_ACTION)
{
printf ("\n");
inError = YES;
if (tokenType != SEMICOLON)
printf (" ERROR: Invalid command \"%s\"\n", token);
if (expectedCommands[0] != -1)
{
printf (" EXPECTING: ");
i = 0;
while (expectedCommands[i] != -1)
{
q = &cmdList[expectedCommands[i]];
printf ("\"%s\"", q->cmdName);
i++;
if (expectedCommands[i+1] == -1 && expectedCommands[i] != -1)
printf (", or ");
else if (expectedCommands[i] != -1)
printf (", ");
if (i % 4 == 0)
printf ("\n ");
if (i % 4 == 0)
printf ("\n ");
}
printf ("\n");
}
//printf ("\n");
}
else if (actionType >= 0)
{
rc = DoAction (actionType);
if (rc == ERROR)
{
printf (" The problem is on line %d of the file named \"%s\"\n", lineNumber, inFile);
goto errorExit;
}
}
}
if (commandNumber == NUMCOMMANDS + RIGHTCOMMENT)
isCommented = NO;
} while (*token && inError == NO);
}
fclose (fp);
return (rc);
errorExit:
fclose (fp);
return (rc);
}
int RealloateTreeParts (void)
{
numPartsAllocated += 100;
treePartsFound = (unsigned *)realloc(treePartsFound, (size_t) (nUnsignedNeeded * numPartsAllocated * sizeof(unsigned)));
if (!treePartsFound)
{
printf (" ERROR: Could not reallocate treePartsFound\n");
free (treeBits);
return (ERROR);
}
numFoundOfThisPart = (int *)realloc(numFoundOfThisPart, (size_t) (numPartsAllocated * sizeof(int)));
if (!numFoundOfThisPart)
{
printf (" ERROR: Could not reallocate numFoundOfThisPart\n");
free (treePartsFound);
free (treeBits);
return (ERROR);
}
aBrlens = (double *)realloc(aBrlens, (size_t) (numPartsAllocated * sizeof(double)));
if (!aBrlens)
{
printf (" ERROR: Could not reallocate aBrlens\n");
free (treePartsFound);
free (treeBits);
free (numFoundOfThisPart);
return (ERROR);
}
aOldBrlens = (double *)realloc(aOldBrlens, (size_t) (numPartsAllocated * sizeof(double)));
if (!aOldBrlens)
{
printf (" ERROR: Could not reallocate aOldBrlens\n");
free (treePartsFound);
free (treeBits);
free (numFoundOfThisPart);
free (aBrlens);
return (ERROR);
}
sBrlens = (double *)realloc(sBrlens, (size_t) (numPartsAllocated * sizeof(double)));
if (!sBrlens)
{
printf (" ERROR: Could not reallocate sBrlens\n");
free (treePartsFound);
free (treeBits);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
return (ERROR);
}
return (NO_ERROR);
}
int ResID (char nuc)
{
char n;
n = nuc;
if (n == '0' || n == 'a' || n == 'A')
{
return 1;
}
else if (n == '1' || n == 'b' || n == 'B')
{
return 2;
}
else if (n == gapChar)
{
return 3;
}
else if (n == missingChar)
{
return 3;
}
else
return -1;
}
int RootTree (TreeNode *p)
{
int i, j, nNodes, *usedMemIndex, availableMemIndex[2], isMarked;
double tempBrLen;
TreeNode **downPass, *first, *second, *lft, *rht, *m1, *m2, *um1, *um2;
/* get down pass sequence */
if (isTreeRooted == YES)
{
printf (" ERROR: Tree is already rooted\n");
return (ERROR);
}
else
{
nNodes = 2 * nTaxa - 2;
}
downPass = (TreeNode **)malloc((size_t) (2 * nTaxa * sizeof(TreeNode *)));
if (!downPass)
{
printf (" ERROR: Could not allocate downPass\n");
return (ERROR);
}
i = 0;
GetUserDownPass (userTreeRoot, downPass, &i);
/* find available nodes */
usedMemIndex = (int *)malloc((size_t) (2 * nTaxa * sizeof(int)));
if (!usedMemIndex)
{
printf (" ERROR: Could not allocate usedMemIndex\n");
return (ERROR);
}
for (i=0; i<2*nTaxa; i++)
usedMemIndex[i] = NO;
for (i=0; i<nNodes; i++)
{
p = downPass[i];
usedMemIndex[p->memoryIndex] = YES;
}
j = 0;
for (i=0; i<2*nTaxa; i++)
{
if (usedMemIndex[i] == NO)
{
if (j <= 1)
{
availableMemIndex[j] = i;
j++;
}
else
{
printf (" ERROR: Too many available nodes\n");
}
}
}
first = &userTree[availableMemIndex[0]];
second = &userTree[availableMemIndex[1]];
free (downPass);
free (usedMemIndex);
/* root tree with previously down taxon as first right */
lft = userTreeRoot->left;
rht = userTreeRoot;
tempBrLen = lft->length;
if (tempBrLen < 0.0)
tempBrLen = 0.0;
lft->anc = first;
rht->left = NULL;
rht->right = NULL;
rht->anc = first;
first->left = lft;
first->right = rht;
first->anc = second;
second->left = first;
second->right = NULL;
second->anc = NULL;
lft->length = tempBrLen * 0.5;
rht->length = tempBrLen * 0.5;
first->length = 0.0;
second->length = 0.0;
userTreeRoot = second;
isTreeRooted = YES;
/* now, bring the outgroup around to the first right position */
downPass = (TreeNode **)malloc((size_t) (2 * nTaxa * sizeof(TreeNode *)));
if (!downPass)
{
printf (" ERROR: Could not allocate downPass\n");
return (ERROR);
}
i = 0;
GetUserDownPass (userTreeRoot, downPass, &i);
isMarked = NO;
for (i=0; i<nNodes; i++)
{
p = downPass[i];
if (p->index == outgroupNum)
{
p->marked = YES;
isMarked = YES;
}
else
p->marked = NO;
}
if (isMarked == NO)
{
printf (" ERROR: Could not find outgroup taxon\n");
return (ERROR);
}
for (i=0; i<nNodes; i++)
{
p = downPass[i];
if (p->left != NULL && p->right != NULL)
if (p->left->marked == YES || p->right->marked == YES)
p->marked = YES;
}
free (downPass);
lft = userTreeRoot->left;
while (lft->left->index != outgroupNum && lft->right->index != outgroupNum)
{
if (lft->left->marked == YES && lft->right->marked == NO)
{
m1 = lft->left;
um1 = lft->right;
if (m1->left != NULL && m1->right != NULL)
{
if (m1->left->marked == YES)
{
m2 = m1->left;
um2 = m1->right;
}
else
{
m2 = m1->right;
um2 = m1->left;
}
lft->left = m2;
lft->right = m1;
m2->anc = lft;
m1->left = um2;
m1->right = um1;
m1->anc = lft;
um1->anc = m1;
um2->anc = m1;
m1->marked = NO;
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
else if (lft->left->marked == NO && lft->right->marked == YES)
{
m1 = lft->right;
um1 = lft->left;
if (m1->left != NULL && m1->right != NULL)
{
if (m1->left->marked == YES)
{
m2 = m1->left;
um2 = m1->right;
}
else
{
m2 = m1->right;
um2 = m1->left;
}
lft->left = m1;
lft->right = m2;
m2->anc = lft;
m1->left = um1;
m1->right = um2;
m1->anc = lft;
um1->anc = m1;
um2->anc = m1;
m1->marked = NO;
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
/* make certain outgroup is to the right of the root */
if (userTreeRoot->left->left->index == outgroupNum)
{
m1 = userTreeRoot->left->left;
m2 = userTreeRoot->left->right;
lft = userTreeRoot->left;
lft->left = m2;
lft->right = m1;
}
/* reindex internal nodes of tree */
i = nTaxa;
FinishTree (userTreeRoot, &i, YES);
return (NO_ERROR);
}
int RootSumTree (TreeNode *p)
{
int i, j, nNodes, *usedMemIndex, availableMemIndex[2], isMarked;
double tempBrLen;
TreeNode **downPass, *first, *second, *lft, *rht, *m1, *m2, *um1, *um2;
/* get down pass sequence */
if (isSumTreeRooted == YES)
{
printf (" ERROR: Tree is already rooted\n");
return (ERROR);
}
else
{
nNodes = 2 * nTaxa - 2;
}
downPass = (TreeNode **)malloc((size_t) (2 * nTaxa * sizeof(TreeNode *)));
if (!downPass)
{
printf (" ERROR: Could not allocate downPass\n");
return (ERROR);
}
i = 0;
GetUserDownPass (sumTreeRoot, downPass, &i);
/* find available nodes */
usedMemIndex = (int *)malloc((size_t) (2 * nTaxa * sizeof(int)));
if (!usedMemIndex)
{
printf (" ERROR: Could not allocate usedMemIndex\n");
return (ERROR);
}
for (i=0; i<2*nTaxa; i++)
usedMemIndex[i] = NO;
for (i=0; i<nNodes; i++)
{
p = downPass[i];
usedMemIndex[p->memoryIndex] = YES;
}
j = 0;
for (i=0; i<2*nTaxa; i++)
{
if (usedMemIndex[i] == NO)
{
if (j <= 1)
{
availableMemIndex[j] = i;
j++;
}
else
{
printf (" ERROR: Too many available nodes\n");
}
}
}
first = &sumTree[availableMemIndex[0]];
second = &sumTree[availableMemIndex[1]];
free (downPass);
free (usedMemIndex);
/* root tree with previously down taxon as first right */
lft = sumTreeRoot->left;
rht = sumTreeRoot;
tempBrLen = lft->length;
if (tempBrLen < 0.0)
tempBrLen = 0.0;
lft->anc = first;
rht->left = NULL;
rht->right = NULL;
rht->anc = first;
first->left = lft;
first->right = rht;
first->anc = second;
second->left = first;
second->right = NULL;
second->anc = NULL;
lft->length = tempBrLen * 0.5;
rht->length = tempBrLen * 0.5;
first->length = 0.0;
second->length = 0.0;
sumTreeRoot = second;
isSumTreeRooted = YES;
/* now, bring the outgroup around to the first right position */
downPass = (TreeNode **)malloc((size_t) (2 * nTaxa * sizeof(TreeNode *)));
if (!downPass)
{
printf (" ERROR: Could not allocate downPass\n");
return (ERROR);
}
i = 0;
GetUserDownPass (sumTreeRoot, downPass, &i);
isMarked = NO;
for (i=0; i<nNodes; i++)
{
p = downPass[i];
if (p->index == outgroupNum)
{
p->marked = YES;
isMarked = YES;
}
else
p->marked = NO;
}
if (isMarked == NO)
{
printf (" ERROR: Could not find outgroup taxon\n");
return (ERROR);
}
for (i=0; i<nNodes; i++)
{
p = downPass[i];
if (p->left != NULL && p->right != NULL)
if (p->left->marked == YES || p->right->marked == YES)
p->marked = YES;
}
free (downPass);
lft = sumTreeRoot->left;
while (lft->left->index != outgroupNum && lft->right->index != outgroupNum)
{
if (lft->left->marked == YES && lft->right->marked == NO)
{
m1 = lft->left;
um1 = lft->right;
if (m1->left != NULL && m1->right != NULL)
{
if (m1->left->marked == YES)
{
m2 = m1->left;
um2 = m1->right;
}
else
{
m2 = m1->right;
um2 = m1->left;
}
lft->left = m2;
lft->right = m1;
m2->anc = lft;
m1->left = um2;
m1->right = um1;
m1->anc = lft;
um1->anc = m1;
um2->anc = m1;
m1->marked = NO;
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
else if (lft->left->marked == NO && lft->right->marked == YES)
{
m1 = lft->right;
um1 = lft->left;
if (m1->left != NULL && m1->right != NULL)
{
if (m1->left->marked == YES)
{
m2 = m1->left;
um2 = m1->right;
}
else
{
m2 = m1->right;
um2 = m1->left;
}
lft->left = m1;
lft->right = m2;
m2->anc = lft;
m1->left = um1;
m1->right = um2;
m1->anc = lft;
um1->anc = m1;
um2->anc = m1;
m1->marked = NO;
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
else
{
printf (" ERROR: Rooting routine is lost\n");
return (ERROR);
}
}
/* make certain outgroup is to the right of the root */
if (sumTreeRoot->left->left->index == outgroupNum)
{
m1 = sumTreeRoot->left->left;
m2 = sumTreeRoot->left->right;
lft = sumTreeRoot->left;
lft->left = m2;
lft->right = m1;
}
/* reindex internal nodes of tree */
i = nTaxa;
FinishTree (sumTreeRoot, &i, YES);
return (NO_ERROR);
}
int SetBits (int n)
{
int i, integerSize, offSet;
unsigned x, y;
/* find out how big an unsigned integer is on this machine */
integerSize = sizeof (unsigned);
//printf ("integer is %d bytes \n", integerSize);
/* decide how many unsigned ints are going to be needed to
represent a taxon number */
nUnsignedNeeded = (n / (integerSize*8)) + 1;
//printf ("nUnsignedNeeded = %d\n", nUnsignedNeeded);
numPartsAllocated = MAX_PARTITIONS;
/* allocate memory */
treeBits = (unsigned *)malloc((size_t) (2 * nTaxa * nUnsignedNeeded * sizeof(unsigned)));
if (!treeBits)
{
printf (" ERROR: Could not allocate treeBits\n");
return (ERROR);
}
treePartsFound = (unsigned *)malloc((size_t) (nUnsignedNeeded * MAX_PARTITIONS * sizeof(unsigned)));
if (!treePartsFound)
{
printf (" ERROR: Could not allocate treePartsFound\n");
free (treeBits);
return (ERROR);
}
numFoundOfThisPart = (int *)malloc((size_t) (MAX_PARTITIONS * sizeof(int)));
if (!numFoundOfThisPart)
{
printf (" ERROR: Could not allocate numFoundOfThisPart\n");
free (treePartsFound);
free (treeBits);
return (ERROR);
}
aBrlens = (double *)malloc((size_t) (MAX_PARTITIONS * sizeof(double)));
if (!aBrlens)
{
printf (" ERROR: Could not allocate aBrlens\n");
free (treePartsFound);
free (treeBits);
free (numFoundOfThisPart);
return (ERROR);
}
aOldBrlens = (double *)malloc((size_t) (MAX_PARTITIONS * sizeof(double)));
if (!aOldBrlens)
{
printf (" ERROR: Could not allocate aOldBrlens\n");
free (treePartsFound);
free (treeBits);
free (numFoundOfThisPart);
free (aBrlens);
return (ERROR);
}
sBrlens = (double *)malloc((size_t) (MAX_PARTITIONS * sizeof(double)));
if (!sBrlens)
{
printf (" ERROR: Could not allocate sBrlens\n");
free (treePartsFound);
free (treeBits);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
return (ERROR);
}
taxonMask = (unsigned *)malloc((size_t) (nUnsignedNeeded * sizeof(unsigned)));
if (!taxonMask)
{
printf (" ERROR: Could not allocate taxonMask\n");
free (treePartsFound);
free (treeBits);
free (numFoundOfThisPart);
free (aBrlens);
free (aOldBrlens);
free (sBrlens);
return (ERROR);
}
for (i=0; i<2*nTaxa*nUnsignedNeeded; i++)
treeBits[i] = 0;
for (i=0; i<nUnsignedNeeded*MAX_PARTITIONS; i++)
treePartsFound[i] = 0;
for (i=0; i<MAX_PARTITIONS; i++)
numFoundOfThisPart[i] = 0;
for (i=0; i<MAX_PARTITIONS; i++)
aBrlens[i] = aOldBrlens[i] = sBrlens[i] = 0.0;
numTreePartsFound = 0;
for (i=0; i<nUnsignedNeeded; i++)
taxonMask[i] = 0;
for (i=0; i<nTaxa; i++)
{
offSet = 0;
while ((i+1) > integerSize*8*(offSet+1))
offSet++;
x = 1 << (i - offSet*integerSize*8);
y = taxonMask[offSet];
taxonMask[offSet] = x | y;
}
/*for (i=0; i<nUnsignedNeeded; i++)
DisplayBits (taxonMask[i]);*/
return (NO_ERROR);
}
void SetUpCommandHierarchy (void)
{
command_list *p;
/* 0: root of command hierarchy */
p = &cmdList[0];
p->index = 0;
p->parent = NULL;
p->left = &cmdList[1];
p->sib = NULL;
p->rNde = NULL;
p->cmd = -1;
p->action = -1;
strcpy(p->cmdName, "#");
/* 1: # */
p = &cmdList[1];
p->index = 1;
p->parent = &cmdList[0];
p->left = &cmdList[2];
p->sib = &cmdList[3];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + POUNDSIGN;
p->action = -1;
strcpy(p->cmdName, "#");
/* 2: NEXUS */
p = &cmdList[2];
p->index = 2;
p->parent = &cmdList[1];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[0];
p->cmd = 27;
p->action = -1;
strcpy(p->cmdName, "NEXUS");
/* 3: begin */
p = &cmdList[3];
p->index = 3;
p->parent = &cmdList[0];
p->left = &cmdList[4];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 1;
p->action = -1;
strcpy(p->cmdName, "begin");
/* 4: data */
p = &cmdList[4];
p->index = 4;
p->parent = &cmdList[3];
p->left = &cmdList[5];
p->sib = &cmdList[40];
p->rNde = NULL;
p->cmd = 4;
p->action = -1;
strcpy(p->cmdName, "data");
/* 5: ; */
p = &cmdList[5];
p->index = 5;
p->parent = &cmdList[4];
p->left = &cmdList[6];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_INIT_DATA_BLOCK;
strcpy(p->cmdName, ";");
/* 6: dimensions */
p = &cmdList[6];
p->index = 6;
p->parent = &cmdList[5];
p->left = &cmdList[7];
p->sib = &cmdList[14];
p->rNde = NULL;
p->cmd = 12;
p->action = -1;
strcpy(p->cmdName, "dimensions");
/* 7: ntax */
p = &cmdList[7];
p->index = 7;
p->parent = &cmdList[6];
p->left = &cmdList[8];
p->sib = &cmdList[10];
p->rNde = NULL;
p->cmd = 13;
p->action = -1;
strcpy(p->cmdName, "ntax");
/* 8: = */
p = &cmdList[8];
p->index = 8;
p->parent = &cmdList[7];
p->left = &cmdList[9];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 9: digit */
p = &cmdList[9];
p->index = 9;
p->parent = &cmdList[8];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[6];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INIT_NTAX;
strcpy(p->cmdName, "<integer>");
/* 10: nchar */
p = &cmdList[10];
p->index = 10;
p->parent = &cmdList[6];
p->left = &cmdList[11];
p->sib = &cmdList[13];
p->rNde = NULL;
p->cmd = 14;
p->action = -1;
strcpy(p->cmdName, "nchar");
/* 11: = */
p = &cmdList[11];
p->index = 11;
p->parent = &cmdList[10];
p->left = &cmdList[12];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 12: digit */
p = &cmdList[12];
p->index = 12;
p->parent = &cmdList[11];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[6];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INIT_NCHAR;
strcpy(p->cmdName, "<integer>");
/* 13: ; */
p = &cmdList[13];
p->index = 13;
p->parent = &cmdList[6];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[5];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_ALLOC_MATRIX;
strcpy(p->cmdName, ";");
/* 14: format */
p = &cmdList[14];
p->index = 14;
p->parent = &cmdList[5];
p->left = &cmdList[15];
p->sib = &cmdList[34];
p->rNde = NULL;
p->cmd = 15;
p->action = -1;
strcpy(p->cmdName, "format");
/* 15: datatype */
p = &cmdList[15];
p->index = 15;
p->parent = &cmdList[14];
p->left = &cmdList[16];
p->sib = &cmdList[20];
p->rNde = NULL;
p->cmd = 16;
p->action = -1;
strcpy(p->cmdName, "datatype");
/* 16: = */
p = &cmdList[16];
p->index = 16;
p->parent = &cmdList[15];
p->left = &cmdList[17];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 17: dna */
p = &cmdList[17];
p->index = 17;
p->parent = &cmdList[16];
p->left = NULL;
p->sib = &cmdList[18];
p->rNde = &cmdList[14];
p->cmd = 19;
p->action = CMD_INIT_DATATYPE;
strcpy(p->cmdName, "dna");
/* 18: rna */
p = &cmdList[18];
p->index = 18;
p->parent = &cmdList[16];
p->left = NULL;
p->sib = &cmdList[19];
p->rNde = &cmdList[14];
p->cmd = 20;
p->action = CMD_INIT_DATATYPE;
strcpy(p->cmdName, "rna");
/* 19: protein */
p = &cmdList[19];
p->index = 19;
p->parent = &cmdList[16];
p->left = NULL;
p->sib = &cmdList[498];
p->rNde = &cmdList[14];
p->cmd = 21;
p->action = CMD_INIT_DATATYPE;
strcpy(p->cmdName, "protein");
/* 20: interleave */
p = &cmdList[20];
p->index = 20;
p->parent = &cmdList[14];
p->left = &cmdList[21];
p->sib = &cmdList[24];
p->rNde = NULL;
p->cmd = 22;
p->action = -1;
strcpy(p->cmdName, "interleave");
/* 21: = */
p = &cmdList[21];
p->index = 21;
p->parent = &cmdList[20];
p->left = &cmdList[22];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 22: yes */
p = &cmdList[22];
p->index = 22;
p->parent = &cmdList[21];
p->left = NULL;
p->sib = &cmdList[23];
p->rNde = &cmdList[14];
p->cmd = 17;
p->action = CMD_INIT_INTERLEAVE;
strcpy(p->cmdName, "yes");
/* 23: no */
p = &cmdList[23];
p->index = 23;
p->parent = &cmdList[21];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[14];
p->cmd = 18;
p->action = CMD_INIT_INTERLEAVE;
strcpy(p->cmdName, "no");
/* 24: gap */
p = &cmdList[24];
p->index = 24;
p->parent = &cmdList[14];
p->left = &cmdList[25];
p->sib = &cmdList[27];
p->rNde = NULL;
p->cmd = 23;
p->action = -1;
strcpy(p->cmdName, "gap");
/* 25: = */
p = &cmdList[25];
p->index = 25;
p->parent = &cmdList[24];
p->left = &cmdList[26];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 26: gapcharacter */
p = &cmdList[26];
p->index = 26;
p->parent = &cmdList[25];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[14];
p->cmd = NUMCOMMANDS + ANYTOKEN;
p->action = CMD_INIT_GAPCHAR;
strcpy(p->cmdName, "<single character>");
/* 27: missing */
p = &cmdList[27];
p->index = 27;
p->parent = &cmdList[14];
p->left = &cmdList[28];
p->sib = &cmdList[30];
p->rNde = NULL;
p->cmd = 25;
p->action = -1;
strcpy(p->cmdName, "missing");
/* 28: = */
p = &cmdList[28];
p->index = 28;
p->parent = &cmdList[27];
p->left = &cmdList[29];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 29: missing character */
p = &cmdList[29];
p->index = 29;
p->parent = &cmdList[28];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[14];
p->cmd = NUMCOMMANDS + ANYTOKEN;
p->action = CMD_INIT_MISSINGCHAR;
strcpy(p->cmdName, "<missing character>");
/* 30: matchchar */
p = &cmdList[30];
p->index = 30;
p->parent = &cmdList[14];
p->left = &cmdList[31];
p->sib = &cmdList[33];
p->rNde = NULL;
p->cmd = 24;
p->action = -1;
strcpy(p->cmdName, "matchchar");
/* 31: = */
p = &cmdList[31];
p->index = 31;
p->parent = &cmdList[30];
p->left = &cmdList[32];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 32: single matching character */
p = &cmdList[32];
p->index = 32;
p->parent = &cmdList[31];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[14];
p->cmd = NUMCOMMANDS + ANYTOKEN;
p->action = CMD_INIT_MATCHCHAR;
strcpy(p->cmdName, "<matching character>");
/* 33: ; */
p = &cmdList[33];
p->index = 33;
p->parent = &cmdList[14];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[5];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = -1;
strcpy(p->cmdName, ";");
/* 34: matrix */
p = &cmdList[34];
p->index = 34;
p->parent = &cmdList[5];
p->left = &cmdList[35];
p->sib = &cmdList[38];
p->rNde = NULL;
p->cmd = 26;
p->action = CMD_INIT_READ_MATRIX;
strcpy(p->cmdName, "matrix");
/* 35: alpha */
p = &cmdList[35];
p->index = 35;
p->parent = &cmdList[34];
p->left = NULL;
p->sib = &cmdList[36];
p->rNde = &cmdList[34];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_FILL_MATRIX;
strcpy(p->cmdName, "");
/* 36: miscellaneous character */
p = &cmdList[36];
p->index = 36;
p->parent = &cmdList[34];
p->left = NULL;
p->sib = &cmdList[37];
p->rNde = &cmdList[34];
p->cmd = NUMCOMMANDS + ANYTOKEN;
p->action = CMD_FILL_MATRIX;
strcpy(p->cmdName, "");
/* 37: ; */
p = &cmdList[37];
p->index = 37;
p->parent = &cmdList[34];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[5];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_FINISH_READ_MATRIX;
strcpy(p->cmdName, ";");
/* 38: end */
p = &cmdList[38];
p->index = 38;
p->parent = &cmdList[5];
p->left = &cmdList[39];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 2;
p->action = -1;
strcpy(p->cmdName, "end");
/* 39: ; */
p = &cmdList[39];
p->index = 39;
p->parent = &cmdList[38];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[0];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_EXIT_DATA_BLOCK;
strcpy(p->cmdName, ";");
/* 40: mrbayes */
p = &cmdList[40];
p->index = 40;
p->parent = &cmdList[3];
p->left = &cmdList[41];
p->sib = &cmdList[333];
p->rNde = NULL;
p->cmd = 3;
p->action = -1;
strcpy(p->cmdName, "mrbayes");
/* 41: ; */
p = &cmdList[41];
p->index = 41;
p->parent = &cmdList[40];
p->left = &cmdList[42];
p->sib = &cmdList[45];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_ENTER_MRBAYES_BLOCK;
strcpy(p->cmdName, ";");
/* 42: execute */
p = &cmdList[42];
p->index = 42;
p->parent = &cmdList[41];
p->left = &cmdList[43];
p->sib = &cmdList[45];
p->rNde = NULL;
p->cmd = 0;
p->action = CMD_ENTER_INPUT_FILE_NAME1;
strcpy(p->cmdName, "execute");
/* 43: filename */
p = &cmdList[43];
p->index = 43;
p->parent = &cmdList[42];
p->left = &cmdList[44];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_ENTER_INPUT_FILE_NAME2;
strcpy(p->cmdName, "<file name>");
/* 44: ; */
p = &cmdList[44];
p->index = 44;
p->parent = &cmdList[43];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_EXECUTE;
strcpy(p->cmdName, ";");
/* 45: quit */
p = &cmdList[45];
p->index = 45;
p->parent = &cmdList[41];
p->left = &cmdList[46];
p->sib = &cmdList[47];
p->rNde = NULL;
p->cmd = 7;
p->action = -1;
strcpy(p->cmdName, "quit");
/* 46: ; */
p = &cmdList[46];
p->index = 46;
p->parent = &cmdList[45];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_QUIT;
strcpy(p->cmdName, ";");
/* 47: end */
p = &cmdList[47];
p->index = 47;
p->parent = &cmdList[41];
p->left = &cmdList[48];
p->sib = &cmdList[49];
p->rNde = NULL;
p->cmd = 2;
p->action = -1;
strcpy(p->cmdName, "end");
/* 48: ; */
p = &cmdList[48];
p->index = 48;
p->parent = &cmdList[47];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_EXIT_MRBAYES_BLOCK;
strcpy(p->cmdName, ";");
/* 49: help */
p = &cmdList[49];
p->index = 49;
p->parent = &cmdList[41];
p->left = &cmdList[50];
p->sib = &cmdList[53];
p->rNde = NULL;
p->cmd = 6;
p->action = CMD_INIT_HELP;
strcpy(p->cmdName, "help");
/* 50: help command */
p = &cmdList[50];
p->index = 50;
p->parent = &cmdList[49];
p->left = &cmdList[51];
p->sib = &cmdList[52];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ANYTOKEN;
p->action = CMD_ENTER_HELP_Q;
strcpy(p->cmdName, "<command name>");
/* 51: ; */
p = &cmdList[51];
p->index = 51;
p->parent = &cmdList[50];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_GET_USER_SOME_HELP;
strcpy(p->cmdName, ";");
/* 52: ; */
p = &cmdList[52];
p->index = 52;
p->parent = &cmdList[49];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_GET_USER_SOME_HELP;
strcpy(p->cmdName, ";");
/* 53: lset */
p = &cmdList[53];
p->index = 53;
p->parent = &cmdList[41];
p->left = &cmdList[54];
p->sib = &cmdList[106];
p->rNde = NULL;
p->cmd = 8;
p->action = -1;
strcpy(p->cmdName, "lset");
/* 54: nst */
p = &cmdList[54];
p->index = 54;
p->parent = &cmdList[53];
p->left = &cmdList[55];
p->sib = &cmdList[57];
p->rNde = NULL;
p->cmd = 9;
p->action = -1;
strcpy(p->cmdName, "nst");
/* 55: = */
p = &cmdList[55];
p->index = 55;
p->parent = &cmdList[54];
p->left = &cmdList[56];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 56: digit */
p = &cmdList[56];
p->index = 56;
p->parent = &cmdList[55];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_NST;
strcpy(p->cmdName, "digit");
/* 57: rates */
p = &cmdList[57];
p->index = 57;
p->parent = &cmdList[53];
p->left = &cmdList[58];
p->sib = &cmdList[63];
p->rNde = NULL;
p->cmd = 11;
p->action = -1;
strcpy(p->cmdName, "rates");
/* 58: = */
p = &cmdList[58];
p->index = 58;
p->parent = &cmdList[57];
p->left = &cmdList[59];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 59: equal */
p = &cmdList[59];
p->index = 59;
p->parent = &cmdList[58];
p->left = NULL;
p->sib = &cmdList[60];
p->rNde = &cmdList[53];
p->cmd = 28;
p->action = CMD_SET_RATES;
strcpy(p->cmdName, "equal");
/* 60: gamma */
p = &cmdList[60];
p->index = 60;
p->parent = &cmdList[58];
p->left = NULL;
p->sib = &cmdList[61];
p->rNde = &cmdList[53];
p->cmd = 29;
p->action = CMD_SET_RATES;
strcpy(p->cmdName, "gamma");
/* 61: sitespec */
p = &cmdList[61];
p->index = 61;
p->parent = &cmdList[58];
p->left = NULL;
p->sib = &cmdList[462];
p->rNde = &cmdList[53];
p->cmd = 30;
p->action = CMD_SET_RATES;
strcpy(p->cmdName, "sitespec");
/* 62: covarion */
p = &cmdList[62];
p->index = 62;
p->parent = &cmdList[53];
p->left = &cmdList[494];
p->sib = &cmdList[520];
p->rNde = NULL;
p->cmd = 31;
p->action = -1;
strcpy(p->cmdName, "covarion");
/* 63: basefreq */
p = &cmdList[63];
p->index = 63;
p->parent = &cmdList[53];
p->left = &cmdList[64];
p->sib = &cmdList[68];
p->rNde = NULL;
p->cmd = 10;
p->action = -1;
strcpy(p->cmdName, "basefreq");
/* 64: = */
p = &cmdList[64];
p->index = 64;
p->parent = &cmdList[63];
p->left = &cmdList[65];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 65: equal */
p = &cmdList[65];
p->index = 65;
p->parent = &cmdList[64];
p->left = NULL;
p->sib = &cmdList[66];
p->rNde = &cmdList[53];
p->cmd = 28;
p->action = CMD_SET_BASE_FREQ;
strcpy(p->cmdName, "equal");
/* 66: empirical */
p = &cmdList[66];
p->index = 66;
p->parent = &cmdList[64];
p->left = NULL;
p->sib = &cmdList[67];
p->rNde = &cmdList[53];
p->cmd = 36;
p->action = CMD_SET_BASE_FREQ;
strcpy(p->cmdName, "empirical");
/* 67: estimate */
p = &cmdList[67];
p->index = 67;
p->parent = &cmdList[64];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 37;
p->action = CMD_SET_BASE_FREQ;
strcpy(p->cmdName, "estimate");
/* 68: clock */
p = &cmdList[68];
p->index = 68;
p->parent = &cmdList[53];
p->left = &cmdList[69];
p->sib = &cmdList[73];
p->rNde = NULL;
p->cmd = 32;
p->action = -1;
strcpy(p->cmdName, "clock");
/* 69: = */
p = &cmdList[69];
p->index = 69;
p->parent = &cmdList[68];
p->left = &cmdList[70];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 70: unconstrained */
p = &cmdList[70];
p->index = 70;
p->parent = &cmdList[69];
p->left = NULL;
p->sib = &cmdList[71];
p->rNde = &cmdList[53];
p->cmd = 33;
p->action = CMD_SET_CLOCK;
strcpy(p->cmdName, "unconstrained");
/* 71: relaxed */
p = &cmdList[71];
p->index = 71;
p->parent = &cmdList[69];
p->left = NULL;
p->sib = &cmdList[72];
p->rNde = &cmdList[53];
p->cmd = 34;
p->action = CMD_SET_CLOCK;
strcpy(p->cmdName, "relaxed");
/* 72: strict */
p = &cmdList[72];
p->index = 72;
p->parent = &cmdList[69];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 35;
p->action = CMD_SET_CLOCK;
strcpy(p->cmdName, "strict");
/* 73: ; */
p = &cmdList[73];
p->index = 73;
p->parent = &cmdList[53];
p->left = NULL;
p->sib = &cmdList[74];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_END_NST;
strcpy(p->cmdName, ";");
/* 74: tratio */
p = &cmdList[74];
p->index = 74;
p->parent = &cmdList[53];
p->left = &cmdList[75];
p->sib = &cmdList[78];
p->rNde = NULL;
p->cmd = 38;
p->action = -1;
strcpy(p->cmdName, "tratio");
/* 75: = */
p = &cmdList[75];
p->index = 75;
p->parent = &cmdList[74];
p->left = &cmdList[76];
p->sib = NULL;
p->rNde = NULL;
p->cmd =NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 76: digit */
p = &cmdList[76];
p->index = 76;
p->parent = &cmdList[75];
p->left = NULL;
p->sib = &cmdList[77];
p->rNde = &cmdList[53];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INIT_TRATIO;
strcpy(p->cmdName, "<number>");
/* 77: estimate */
p = &cmdList[77];
p->index = 77;
p->parent = &cmdList[75];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 37;
p->action = CMD_INIT_TRATIO;
strcpy(p->cmdName, "estimate");
/* 78: revmat */
p = &cmdList[78];
p->index = 78;
p->parent = &cmdList[53];
p->left = &cmdList[79];
p->sib = &cmdList[85];
p->rNde = NULL;
p->cmd = 39;
p->action = -1;
strcpy(p->cmdName, "revmat");
/* 79: = */
p = &cmdList[79];
p->index = 79;
p->parent = &cmdList[78];
p->left = &cmdList[80];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 80: ( */
p = &cmdList[80];
p->index = 80;
p->parent = &cmdList[79];
p->left = &cmdList[82];
p->sib = &cmdList[81];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = CMD_INIT_REVRATES;
strcpy(p->cmdName, "(");
/* 81: estimate */
p = &cmdList[81];
p->index = 81;
p->parent = &cmdList[79];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 37;
p->action = CMD_INIT_REVRATES;
strcpy(p->cmdName, "estimate");
/* 82: digit */
p = &cmdList[82];
p->index = 82;
p->parent = &cmdList[80];
p->left = &cmdList[83];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INIT_REVRATES2;
strcpy(p->cmdName, "<number>");
/* 83: , */
p = &cmdList[83];
p->index = 83;
p->parent = &cmdList[82];
p->left = NULL;
p->sib = &cmdList[84];
p->rNde = &cmdList[80];
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 84: ) */
p = &cmdList[84];
p->index = 84;
p->parent = &cmdList[82];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = CMD_INIT_REVRATES3;
strcpy(p->cmdName, ")");
/* 85: nonrevmat */
p = &cmdList[85];
p->index = 85;
p->parent = &cmdList[53];
p->left = &cmdList[86];
p->sib = &cmdList[92];
p->rNde = NULL;
p->cmd = 40;
p->action = -1;
strcpy(p->cmdName, "nonrevmat");
/* 86: = */
p = &cmdList[86];
p->index = 86;
p->parent = &cmdList[85];
p->left = &cmdList[87];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 87: ( */
p = &cmdList[87];
p->index = 87;
p->parent = &cmdList[86];
p->left = &cmdList[89];
p->sib = &cmdList[88];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = CMD_INIT_NONREVRATES;
strcpy(p->cmdName, "(");
/* 88: estimate */
p = &cmdList[88];
p->index = 88;
p->parent = &cmdList[86];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 37;
p->action = CMD_INIT_NONREVRATES;
strcpy(p->cmdName, "estimate");
/* 89: digit */
p = &cmdList[89];
p->index = 89;
p->parent = &cmdList[87];
p->left = &cmdList[90];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INIT_NONREVRATES2;
strcpy(p->cmdName, "<number>");
/* 90: , */
p = &cmdList[90];
p->index = 90;
p->parent = &cmdList[89];
p->left = NULL;
p->sib = &cmdList[91];
p->rNde = &cmdList[87];
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 91: ) */
p = &cmdList[91];
p->index = 91;
p->parent = &cmdList[89];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = CMD_INIT_NONREVRATES3;
strcpy(p->cmdName, ")");
/* 92: shape */
p = &cmdList[92];
p->index = 92;
p->parent = &cmdList[53];
p->left = &cmdList[93];
p->sib = &cmdList[96];
p->rNde = NULL;
p->cmd = 41;
p->action = -1;
strcpy(p->cmdName, "shape");
/* 93: = */
p = &cmdList[93];
p->index = 93;
p->parent = &cmdList[92];
p->left = &cmdList[94];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 94: digit */
p = &cmdList[94];
p->index = 94;
p->parent = &cmdList[93];
p->left = NULL;
p->sib = &cmdList[95];
p->rNde = &cmdList[53];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INIT_SHAPE;
strcpy(p->cmdName, "<number>");
/* 95: estimate */
p = &cmdList[95];
p->index = 95;
p->parent = &cmdList[93];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 37;
p->action = CMD_INIT_SHAPE;
strcpy(p->cmdName, "estimate");
/* 96: sitepartition */
p = &cmdList[96];
p->index = 96;
p->parent = &cmdList[53];
p->left = &cmdList[97];
p->sib = &cmdList[99];
p->rNde = NULL;
p->cmd = 42;
p->action = -1;
strcpy(p->cmdName, "sitepartition");
/* 97: = */
p = &cmdList[97];
p->index = 97;
p->parent = &cmdList[96];
p->left = &cmdList[98];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 98: alpha */
p = &cmdList[98];
p->index = 98;
p->parent = &cmdList[97];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_INIT_PARTITION;
strcpy(p->cmdName, "<partition name>");
/* 99: siterates */
p = &cmdList[99];
p->index = 99;
p->parent = &cmdList[53];
p->left = &cmdList[100];
p->sib = &cmdList[282];
p->rNde = NULL;
p->cmd = 43;
p->action = -1;
strcpy(p->cmdName, "siterates");
/* 100: = */
p = &cmdList[100];
p->index = 100;
p->parent = &cmdList[99];
p->left = &cmdList[101];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 101: ( */
p = &cmdList[101];
p->index = 101;
p->parent = &cmdList[100];
p->left = &cmdList[102];
p->sib = &cmdList[105];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = CMD_INIT_SITERATES;
strcpy(p->cmdName, "(");
/* 102: digit */
p = &cmdList[102];
p->index = 102;
p->parent = &cmdList[101];
p->left = &cmdList[103];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INIT_SITERATES2;
strcpy(p->cmdName, "<number>");
/* 103: , */
p = &cmdList[103];
p->index = 103;
p->parent = &cmdList[102];
p->left = NULL;
p->sib = &cmdList[104];
p->rNde = &cmdList[101];
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 104: ) */
p = &cmdList[104];
p->index = 104;
p->parent = &cmdList[102];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 105: estimate */
p = &cmdList[105];
p->index = 105;
p->parent = &cmdList[100];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 37;
p->action = CMD_INIT_SITERATES;
strcpy(p->cmdName, "estimate");
/* 106: exclude */
p = &cmdList[106];
p->index = 106;
p->parent = &cmdList[41];
p->left = &cmdList[107];
p->sib = &cmdList[111];
p->rNde = NULL;
p->cmd = 46;
p->action = CMD_INIT_EXCLUDE;
strcpy(p->cmdName, "exclude");
/* 107: digit */
p = &cmdList[107];
p->index = 107;
p->parent = &cmdList[106];
p->left = NULL;
p->sib = &cmdList[108];
p->rNde = &cmdList[106];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_EXCLUDE;
strcpy(p->cmdName, "<number>");
/* 108: - */
p = &cmdList[108];
p->index = 108;
p->parent = &cmdList[106];
p->left = NULL;
p->sib = &cmdList[109];
p->rNde = &cmdList[106];
p->cmd = NUMCOMMANDS + DASH;
p->action = CMD_EXCLUDE;
strcpy(p->cmdName, "-");
/* 109: name */
p = &cmdList[109];
p->index = 109;
p->parent = &cmdList[106];
p->left = NULL;
p->sib = &cmdList[110];
p->rNde = &cmdList[106];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_EXCLUDE2;
strcpy(p->cmdName, "<character set>");
/* 110: ; */
p = &cmdList[110];
p->index = 110;
p->parent = &cmdList[106];
p->left = NULL;
p->sib = &cmdList[261];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_EXCLUDE3;
strcpy(p->cmdName, ";");
/* 111: charset */
p = &cmdList[111];
p->index = 111;
p->parent = &cmdList[41];
p->left = &cmdList[112];
p->sib = &cmdList[118];
p->rNde = NULL;
p->cmd = 45;
p->action = -1;
strcpy(p->cmdName, "charset");
/* 112: name */
p = &cmdList[112];
p->index = 112;
p->parent = &cmdList[111];
p->left = &cmdList[113];
p->sib = &cmdList[129];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_INIT_CHARSET_NAME;
strcpy(p->cmdName, "<charset name>");
/* 113: = */
p = &cmdList[113];
p->index = 113;
p->parent = &cmdList[112];
p->left = &cmdList[114];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 114: digit */
p = &cmdList[114];
p->index = 114;
p->parent = &cmdList[113];
p->left = NULL;
p->sib = &cmdList[115];
p->rNde = &cmdList[113];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INIT_CHARSET;
strcpy(p->cmdName, "<number>");
/* 115: - */
p = &cmdList[115];
p->index = 115;
p->parent = &cmdList[113];
p->left = NULL;
p->sib = &cmdList[116];
p->rNde = &cmdList[113];
p->cmd = NUMCOMMANDS + DASH;
p->action = CMD_INIT_CHARSET;
strcpy(p->cmdName, "-");
/* 116: \ */
p = &cmdList[116];
p->index = 116;
p->parent = &cmdList[113];
p->left = NULL;
p->sib = &cmdList[117];
p->rNde = &cmdList[113];
p->cmd = NUMCOMMANDS + FORWARDSLASH;
p->action = CMD_INIT_CHARSET;
strcpy(p->cmdName, "\\");
/* 117: ; */
p = &cmdList[117];
p->index = 117;
p->parent = &cmdList[113];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_INIT_CHARSET2;
strcpy(p->cmdName, ";");
/* 118: partition */
p = &cmdList[118];
p->index = 118;
p->parent = &cmdList[41];
p->left = &cmdList[119];
p->sib = &cmdList[130];
p->rNde = NULL;
p->cmd = 44;
p->action = -1;
strcpy(p->cmdName, "partition");
/* 119: name */
p = &cmdList[119];
p->index = 119;
p->parent = &cmdList[118];
p->left = &cmdList[120];
p->sib = &cmdList[128];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_DEF_PARTITION;
strcpy(p->cmdName, "<partition name>");
/* 120: = */
p = &cmdList[120];
p->index = 120;
p->parent = &cmdList[119];
p->left = &cmdList[121];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 121: digit */
p = &cmdList[121];
p->index = 121;
p->parent = &cmdList[120];
p->left = &cmdList[122];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PARTITION2;
strcpy(p->cmdName, "<number partitions>");
/* 122: : */
p = &cmdList[122];
p->index = 122;
p->parent = &cmdList[121];
p->left = &cmdList[123];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COLON;
p->action = CMD_PARTITION3;
strcpy(p->cmdName, ":");
/* 123: digit */
p = &cmdList[123];
p->index = 123;
p->parent = &cmdList[122];
p->left = NULL;
p->sib = &cmdList[124];
p->rNde = &cmdList[122];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PARTITION4;
strcpy(p->cmdName, "<number>");
/* 124: - */
p = &cmdList[124];
p->index = 124;
p->parent = &cmdList[122];
p->left = NULL;
p->sib = &cmdList[125];
p->rNde = &cmdList[122];
p->cmd = NUMCOMMANDS + DASH;
p->action = CMD_PARTITION4;
strcpy(p->cmdName, "-");
/* 125: name */
p = &cmdList[125];
p->index = 125;
p->parent = &cmdList[122];
p->left = NULL;
p->sib = &cmdList[126];
p->rNde = &cmdList[122];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_PARTITION6;
strcpy(p->cmdName, "<charset name>");
/* 126: \ */
p = &cmdList[126];
p->index = 126;
p->parent = &cmdList[122];
p->left = NULL;
p->sib = &cmdList[127];
p->rNde = &cmdList[122];
p->cmd = NUMCOMMANDS + FORWARDSLASH;
p->action = CMD_PARTITION4;
strcpy(p->cmdName, "\\");
/* 127: ; */
p = &cmdList[127];
p->index = 127;
p->parent = &cmdList[122];
p->left = NULL;
p->sib = &cmdList[134];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_PARTITION5;
strcpy(p->cmdName, ";");
/* 128: number */
p = &cmdList[128];
p->index = 128;
p->parent = &cmdList[118];
p->left = &cmdList[120];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PARTITION;
strcpy(p->cmdName, "<partition number>");
/* 129: number */
p = &cmdList[129];
p->index = 129;
p->parent = &cmdList[111];
p->left = &cmdList[113];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INIT_CHARSET_NAME2;
strcpy(p->cmdName, "<charset number>");
/* 130: outgroup */
p = &cmdList[130];
p->index = 130;
p->parent = &cmdList[41];
p->left = &cmdList[131];
p->sib = &cmdList[135];
p->rNde = NULL;
p->cmd = 47;
p->action = -1;
strcpy(p->cmdName, "outgroup");
/* 131: name */
p = &cmdList[131];
p->index = 131;
p->parent = &cmdList[130];
p->left = &cmdList[133];
p->sib = &cmdList[132];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_DEF_OUTGROUP1;
strcpy(p->cmdName, "<taxon name>");
/* 132: number */
p = &cmdList[132];
p->index = 132;
p->parent = &cmdList[130];
p->left = &cmdList[133];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_DEF_OUTGROUP2;
strcpy(p->cmdName, "<taxon number>");
/* 133: ; */
p = &cmdList[133];
p->index = 133;
p->parent = &cmdList[131];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = -1;
strcpy(p->cmdName, ";");
/* 134: , */
p = &cmdList[134];
p->index = 134;
p->parent = &cmdList[122];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[122];
p->cmd = NUMCOMMANDS + COMMA;
p->action = CMD_PARTITION5;
strcpy(p->cmdName, ",");
/* 135: charstat */
p = &cmdList[135];
p->index = 135;
p->parent = &cmdList[41];
p->left = &cmdList[136];
p->sib = &cmdList[137];
p->rNde = NULL;
p->cmd = 48;
p->action = -1;
strcpy(p->cmdName, "charstat");
/* 136: ; */
p = &cmdList[136];
p->index = 136;
p->parent = &cmdList[135];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SHOW_CHAR_STAT;
strcpy(p->cmdName, ";");
/* 137: calibration */
p = &cmdList[137];
p->index = 137;
p->parent = &cmdList[41];
p->left = &cmdList[138];
p->sib = &cmdList[147];
p->rNde = NULL;
p->cmd = 49;
p->action = -1;
strcpy(p->cmdName, "calibration");
/* 138: name */
p = &cmdList[138];
p->index = 138;
p->parent = &cmdList[137];
p->left = &cmdList[139];
p->sib = &cmdList[162];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_CALIBRATION1;
strcpy(p->cmdName, "<calibration name>");
/* 139: = */
p = &cmdList[139];
p->index = 139;
p->parent = &cmdList[138];
p->left = &cmdList[140];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 140: ( */
p = &cmdList[140];
p->index = 140;
p->parent = &cmdList[139];
p->left = &cmdList[141];
p->sib = &cmdList[145];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 141: digit */
p = &cmdList[141];
p->index = 141;
p->parent = &cmdList[140];
p->left = &cmdList[142];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_CALIBRATION3;
strcpy(p->cmdName, "<time>");
/* 142: , */
p = &cmdList[142];
p->index = 142;
p->parent = &cmdList[141];
p->left = &cmdList[143];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 143: digit */
p = &cmdList[143];
p->index = 143;
p->parent = &cmdList[142];
p->left = &cmdList[144];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_CALIBRATION4;
strcpy(p->cmdName, "<error>");
/* 144: ) */
p = &cmdList[144];
p->index = 144;
p->parent = &cmdList[143];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[139];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 145: name */
p = &cmdList[145];
p->index = 145;
p->parent = &cmdList[139];
p->left = NULL;
p->sib = &cmdList[146];
p->rNde = &cmdList[139];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_CALIBRATION5;
strcpy(p->cmdName, "<taxon name>");
/* 146: ; */
p = &cmdList[146];
p->index = 146;
p->parent = &cmdList[139];
p->left = NULL;
p->sib = &cmdList[161];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_CALIBRATION7;
strcpy(p->cmdName, ";");
/* 147: constraint */
p = &cmdList[147];
p->index = 147;
p->parent = &cmdList[41];
p->left = &cmdList[148];
p->sib = &cmdList[152];
p->rNde = NULL;
p->cmd = 50;
p->action = -1;
strcpy(p->cmdName, "constraint");
/* 148: name */
p = &cmdList[148];
p->index = 148;
p->parent = &cmdList[147];
p->left = &cmdList[149];
p->sib = &cmdList[163];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_CONSTRAINT1;
strcpy(p->cmdName, "<constraint name>");
/* 149: = */
p = &cmdList[149];
p->index = 149;
p->parent = &cmdList[148];
p->left = &cmdList[150];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 150: name */
p = &cmdList[150];
p->index = 150;
p->parent = &cmdList[149];
p->left = NULL;
p->sib = &cmdList[151];
p->rNde = &cmdList[149];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_CONSTRAINT3;
strcpy(p->cmdName, "<taxon name>");
/* 151: ; */
p = &cmdList[151];
p->index = 151;
p->parent = &cmdList[149];
p->left = NULL;
p->sib = &cmdList[164];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_CONSTRAINT5;
strcpy(p->cmdName, ";");
/* 152: compchar */
p = &cmdList[152];
p->index = 152;
p->parent = &cmdList[41];
p->left = &cmdList[153];
p->sib = &cmdList[165];
p->rNde = NULL;
p->cmd = 51;
p->action = -1;
strcpy(p->cmdName, "compchar");
/* 153: number */
p = &cmdList[153];
p->index = 153;
p->parent = &cmdList[152];
p->left = &cmdList[154];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = -1;
strcpy(p->cmdName, "<dimension>");
/* 154: : */
p = &cmdList[154];
p->index = 154;
p->parent = &cmdList[153];
p->left = &cmdList[155];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COLON;
p->action = -1;
strcpy(p->cmdName, ":");
/* 155: { */
p = &cmdList[155];
p->index = 155;
p->parent = &cmdList[154];
p->left = &cmdList[156];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTCURLY;
p->action = -1;
strcpy(p->cmdName, "{");
/* 156: digit */
p = &cmdList[156];
p->index = 156;
p->parent = &cmdList[155];
p->left = &cmdList[157];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = -1;
strcpy(p->cmdName, "<character x>");
/* 157: , */
p = &cmdList[157];
p->index = 157;
p->parent = &cmdList[156];
p->left = NULL;
p->sib = &cmdList[158];
p->rNde = &cmdList[155];
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 158: } */
p = &cmdList[158];
p->index = 158;
p->parent = &cmdList[156];
p->left = &cmdList[159];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + RIGHTCURLY;
p->action = -1;
strcpy(p->cmdName, "}");
/* 159: , */
p = &cmdList[159];
p->index = 159;
p->parent = &cmdList[158];
p->left = NULL;
p->sib = &cmdList[160];
p->rNde = &cmdList[154];
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 160: ; */
p = &cmdList[160];
p->index = 160;
p->parent = &cmdList[158];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = -1;
strcpy(p->cmdName, ";");
/* 161: number */
p = &cmdList[161];
p->index = 161;
p->parent = &cmdList[139];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[139];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_CALIBRATION6;
strcpy(p->cmdName, "<taxon number>");
/* 162: number */
p = &cmdList[162];
p->index = 162;
p->parent = &cmdList[137];
p->left = &cmdList[139];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_CALIBRATION2;
strcpy(p->cmdName, "<calibration number>");
/* 163: number */
p = &cmdList[163];
p->index = 163;
p->parent = &cmdList[137];
p->left = &cmdList[149];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_CONSTRAINT2;
strcpy(p->cmdName, "<constraint number>");
/* 164: digit */
p = &cmdList[164];
p->index = 164;
p->parent = &cmdList[149];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[149];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_CONSTRAINT4;
strcpy(p->cmdName, "<taxon number>");
/* 165: include */
p = &cmdList[165];
p->index = 165;
p->parent = &cmdList[41];
p->left = &cmdList[166];
p->sib = &cmdList[170];
p->rNde = NULL;
p->cmd = 53;
p->action = CMD_INIT_INCLUDE;
strcpy(p->cmdName, "include");
/* 166: digit */
p = &cmdList[166];
p->index = 166;
p->parent = &cmdList[165];
p->left = NULL;
p->sib = &cmdList[167];
p->rNde = &cmdList[165];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INCLUDE;
strcpy(p->cmdName, "<character number>");
/* 167: - */
p = &cmdList[167];
p->index = 167;
p->parent = &cmdList[165];
p->left = NULL;
p->sib = &cmdList[168];
p->rNde = &cmdList[165];
p->cmd = NUMCOMMANDS + DASH;
p->action = CMD_INCLUDE;
strcpy(p->cmdName, "-");
/* 168: name */
p = &cmdList[168];
p->index = 168;
p->parent = &cmdList[165];
p->left = NULL;
p->sib = &cmdList[169];
p->rNde = &cmdList[165];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_INCLUDE2;
strcpy(p->cmdName, "<charset name>");
/* 169: ; */
p = &cmdList[169];
p->index = 169;
p->parent = &cmdList[165];
p->left = NULL;
p->sib = &cmdList[262];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_INCLUDE3;
strcpy(p->cmdName, ";");
/* 170: delete */
p = &cmdList[170];
p->index = 170;
p->parent = &cmdList[41];
p->left = &cmdList[171];
p->sib = &cmdList[174];
p->rNde = NULL;
p->cmd = 54;
p->action = -1;
strcpy(p->cmdName, "delete");
/* 171: name */
p = &cmdList[171];
p->index = 171;
p->parent = &cmdList[170];
p->left = NULL;
p->sib = &cmdList[172];
p->rNde = &cmdList[170];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_DELETE1;
strcpy(p->cmdName, "<taxon name>");
/* 172: ; */
p = &cmdList[172];
p->index = 172;
p->parent = &cmdList[170];
p->left = NULL;
p->sib = &cmdList[173];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = -1;
strcpy(p->cmdName, ";");
/* 173: digit */
p = &cmdList[173];
p->index = 173;
p->parent = &cmdList[170];
p->left = NULL;
p->sib = &cmdList[263];
p->rNde = &cmdList[170];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_DELETE2;
strcpy(p->cmdName, "<taxon number>");
/* 174: restore */
p = &cmdList[174];
p->index = 174;
p->parent = &cmdList[41];
p->left = &cmdList[175];
p->sib = &cmdList[178];
p->rNde = NULL;
p->cmd = 55;
p->action = -1;
strcpy(p->cmdName, "restore");
/* 175: name */
p = &cmdList[175];
p->index = 175;
p->parent = &cmdList[174];
p->left = NULL;
p->sib = &cmdList[176];
p->rNde = &cmdList[174];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_RESTORE1;
strcpy(p->cmdName, "<taxon name>");
/* 176: digit */
p = &cmdList[176];
p->index = 176;
p->parent = &cmdList[174];
p->left = NULL;
p->sib = &cmdList[177];
p->rNde = &cmdList[174];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_RESTORE2;
strcpy(p->cmdName, "<taxon number>");
/* 177: ; */
p = &cmdList[177];
p->index = 177;
p->parent = &cmdList[174];
p->left = NULL;
p->sib = &cmdList[264];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = -1;
strcpy(p->cmdName, ";");
/* 178: mcmc */
p = &cmdList[178];
p->index = 178;
p->parent = &cmdList[41];
p->left = &cmdList[179];
p->sib = &cmdList[201];
p->rNde = NULL;
p->cmd = 56;
p->action = CMD_MCMC;
strcpy(p->cmdName, "mcmc");
/* 179: seed */
p = &cmdList[179];
p->index = 179;
p->parent = &cmdList[178];
p->left = &cmdList[180];
p->sib = &cmdList[182];
p->rNde = NULL;
p->cmd = 57;
p->action = -1;
strcpy(p->cmdName, "seed");
/* 180: = */
p = &cmdList[180];
p->index = 180;
p->parent = &cmdList[179];
p->left = &cmdList[181];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 181: digit */
p = &cmdList[181];
p->index = 181;
p->parent = &cmdList[180];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC1;
strcpy(p->cmdName, "<integer>");
/* 182: ngen */
p = &cmdList[182];
p->index = 182;
p->parent = &cmdList[178];
p->left = &cmdList[183];
p->sib = &cmdList[185];
p->rNde = NULL;
p->cmd = 58;
p->action = -1;
strcpy(p->cmdName, "ngen");
/* 183: = */
p = &cmdList[183];
p->index = 183;
p->parent = &cmdList[182];
p->left = &cmdList[184];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 184: digit */
p = &cmdList[184];
p->index = 184;
p->parent = &cmdList[183];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC2;
strcpy(p->cmdName, "<number generations>");
/* 185: samplefreq */
p = &cmdList[185];
p->index = 185;
p->parent = &cmdList[178];
p->left = &cmdList[186];
p->sib = &cmdList[188];
p->rNde = NULL;
p->cmd = 59;
p->action = -1;
strcpy(p->cmdName, "samplefreq");
/* 186: = */
p = &cmdList[186];
p->index = 186;
p->parent = &cmdList[185];
p->left = &cmdList[187];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 187: digit */
p = &cmdList[187];
p->index = 187;
p->parent = &cmdList[186];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC3;
strcpy(p->cmdName, "<sample frequency");
/* 188: printfreq */
p = &cmdList[188];
p->index = 188;
p->parent = &cmdList[178];
p->left = &cmdList[189];
p->sib = &cmdList[191];
p->rNde = NULL;
p->cmd = 60;
p->action = -1;
strcpy(p->cmdName, "printfreq");
/* 189: = */
p = &cmdList[189];
p->index = 189;
p->parent = &cmdList[188];
p->left = &cmdList[190];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 190: digit */
p = &cmdList[190];
p->index = 190;
p->parent = &cmdList[189];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC4;
strcpy(p->cmdName, "<print frequency>");
/* 191: nchains */
p = &cmdList[191];
p->index = 191;
p->parent = &cmdList[178];
p->left = &cmdList[192];
p->sib = &cmdList[194];
p->rNde = NULL;
p->cmd = 61;
p->action = -1;
strcpy(p->cmdName, "nchains");
/* 192: = */
p = &cmdList[192];
p->index = 192;
p->parent = &cmdList[191];
p->left = &cmdList[193];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 193: digit */
p = &cmdList[193];
p->index = 193;
p->parent = &cmdList[192];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC5;
strcpy(p->cmdName, "<number of chains>");
/* 194: temp */
p = &cmdList[194];
p->index = 194;
p->parent = &cmdList[178];
p->left = &cmdList[195];
p->sib = &cmdList[197];
p->rNde = NULL;
p->cmd = 62;
p->action = -1;
strcpy(p->cmdName, "temp");
/* 195: = */
p = &cmdList[195];
p->index = 195;
p->parent = &cmdList[194];
p->left = &cmdList[196];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 196: digit */
p = &cmdList[196];
p->index = 196;
p->parent = &cmdList[195];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC6;
strcpy(p->cmdName, "<temperature>");
/* 197: filename */
p = &cmdList[197];
p->index = 197;
p->parent = &cmdList[178];
p->left = &cmdList[198];
p->sib = &cmdList[200];
p->rNde = NULL;
p->cmd = 63;
p->action = -1;
strcpy(p->cmdName, "filename");
/* 198: = */
p = &cmdList[198];
p->index = 198;
p->parent = &cmdList[197];
p->left = &cmdList[199];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 199: name */
p = &cmdList[199];
p->index = 199;
p->parent = &cmdList[198];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_MCMC7;
strcpy(p->cmdName, "<file name>");
/* 200: ; */
p = &cmdList[200];
p->index = 200;
p->parent = &cmdList[178];
p->left = NULL;
p->sib = &cmdList[266];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_MCMC8;
strcpy(p->cmdName, ";");
/* 201: prset */
p = &cmdList[201];
p->index = 201;
p->parent = &cmdList[41];
p->left = &cmdList[202];
p->sib = &cmdList[270];
p->rNde = NULL;
p->cmd = 64;
p->action = -1;
strcpy(p->cmdName, "prset");
/* 202: qmatpr */
p = &cmdList[202];
p->index = 202;
p->parent = &cmdList[201];
p->left = &cmdList[203];
p->sib = &cmdList[215];
p->rNde = NULL;
p->cmd = 65;
p->action = -1;
strcpy(p->cmdName, "qmatpr");
/* 203: = */
p = &cmdList[203];
p->index = 203;
p->parent = &cmdList[202];
p->left = &cmdList[204];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 204: fixed */
p = &cmdList[204];
p->index = 204;
p->parent = &cmdList[203];
p->left = NULL;
p->sib = &cmdList[205];
p->rNde = &cmdList[201];
p->cmd = 66;
p->action = CMD_PRIOR1;
strcpy(p->cmdName, "fixed");
/* 205: exp */
p = &cmdList[205];
p->index = 205;
p->parent = &cmdList[203];
p->left = &cmdList[206];
p->sib = &cmdList[209];
p->rNde = NULL;
p->cmd = 67;
p->action = CMD_PRIOR2;
strcpy(p->cmdName, "exp");
/* 206: ( */
p = &cmdList[206];
p->index = 206;
p->parent = &cmdList[205];
p->left = &cmdList[207];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 207: digit */
p = &cmdList[207];
p->index = 207;
p->parent = &cmdList[206];
p->left = &cmdList[208];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR4;
strcpy(p->cmdName, "<number>");
/* 208: ) */
p = &cmdList[208];
p->index = 208;
p->parent = &cmdList[207];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 209: uni */
p = &cmdList[209];
p->index = 209;
p->parent = &cmdList[203];
p->left = &cmdList[210];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 68;
p->action = CMD_PRIOR3;
strcpy(p->cmdName, "uni");
/* 210: ( */
p = &cmdList[210];
p->index = 210;
p->parent = &cmdList[209];
p->left = &cmdList[211];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 211: digit */
p = &cmdList[211];
p->index = 211;
p->parent = &cmdList[210];
p->left = &cmdList[212];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR5;
strcpy(p->cmdName, "<number>");
/* 212: , */
p = &cmdList[212];
p->index = 212;
p->parent = &cmdList[211];
p->left = &cmdList[213];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 213: digit */
p = &cmdList[213];
p->index = 213;
p->parent = &cmdList[212];
p->left = &cmdList[214];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR6;
strcpy(p->cmdName, "digit");
/* 214: ) */
p = &cmdList[214];
p->index = 214;
p->parent = &cmdList[213];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 215: basefreqpr */
p = &cmdList[215];
p->index = 215;
p->parent = &cmdList[201];
p->left = &cmdList[216];
p->sib = &cmdList[222];
p->rNde = NULL;
p->cmd = 69;
p->action = -1;
strcpy(p->cmdName, "basefreqpr");
/* 216: = */
p = &cmdList[216];
p->index = 216;
p->parent = &cmdList[215];
p->left = &cmdList[217];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 217: fixed */
p = &cmdList[217];
p->index = 217;
p->parent = &cmdList[216];
p->left = NULL;
p->sib = &cmdList[218];
p->rNde = &cmdList[201];
p->cmd = 66;
p->action = CMD_PRIOR7;
strcpy(p->cmdName, "fixed");
/* 218: dir */
p = &cmdList[218];
p->index = 218;
p->parent = &cmdList[216];
p->left = &cmdList[219];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 70;
p->action = CMD_PRIOR8;
strcpy(p->cmdName, "dir");
/* 219: ( */
p = &cmdList[219];
p->index = 219;
p->parent = &cmdList[218];
p->left = &cmdList[220];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 220: digit */
p = &cmdList[220];
p->index = 220;
p->parent = &cmdList[219];
p->left = &cmdList[221];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR9;
strcpy(p->cmdName, "<number>");
/* 221: ) */
p = &cmdList[221];
p->index = 221;
p->parent = &cmdList[220];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 222: brlenpr */
p = &cmdList[222];
p->index = 222;
p->parent = &cmdList[201];
p->left = &cmdList[223];
p->sib = &cmdList[234];
p->rNde = NULL;
p->cmd = 71;
p->action = -1;
strcpy(p->cmdName, "brlenpr");
/* 223: = */
p = &cmdList[223];
p->index = 223;
p->parent = &cmdList[222];
p->left = &cmdList[224];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 224: uni */
p = &cmdList[224];
p->index = 224;
p->parent = &cmdList[223];
p->left = &cmdList[225];
p->sib = &cmdList[230];
p->rNde = NULL;
p->cmd = 68;
p->action = CMD_PRIOR10;
strcpy(p->cmdName, "uni");
/* 225: ( */
p = &cmdList[225];
p->index = 225;
p->parent = &cmdList[224];
p->left = &cmdList[226];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 226: digit */
p = &cmdList[226];
p->index = 226;
p->parent = &cmdList[225];
p->left = &cmdList[227];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR13;
strcpy(p->cmdName, "<number>");
/* 227: , */
p = &cmdList[227];
p->index = 227;
p->parent = &cmdList[226];
p->left = &cmdList[228];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 228: digit */
p = &cmdList[228];
p->index = 228;
p->parent = &cmdList[227];
p->left = &cmdList[229];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR14;
strcpy(p->cmdName, "<number>");
/* 229: ) */
p = &cmdList[229];
p->index = 229;
p->parent = &cmdList[228];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 230: exp */
p = &cmdList[230];
p->index = 230;
p->parent = &cmdList[223];
p->left = &cmdList[231];
p->sib = &cmdList[260];
p->rNde = NULL;
p->cmd = 67;
p->action = CMD_PRIOR11;
strcpy(p->cmdName, "exp");
/* 231: ( */
p = &cmdList[231];
p->index = 231;
p->parent = &cmdList[230];
p->left = &cmdList[232];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 232: digit */
p = &cmdList[232];
p->index = 232;
p->parent = &cmdList[231];
p->left = &cmdList[233];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR15;
strcpy(p->cmdName, "<number>");
/* 233: ) */
p = &cmdList[233];
p->index = 233;
p->parent = &cmdList[232];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 234: shapepr */
p = &cmdList[234];
p->index = 234;
p->parent = &cmdList[201];
p->left = &cmdList[235];
p->sib = &cmdList[247];
p->rNde = NULL;
p->cmd = 73;
p->action = -1;
strcpy(p->cmdName, "shapepr");
/* 235: = */
p = &cmdList[235];
p->index = 235;
p->parent = &cmdList[234];
p->left = &cmdList[236];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 236: fixed */
p = &cmdList[236];
p->index = 236;
p->parent = &cmdList[235];
p->left = NULL;
p->sib = &cmdList[237];
p->rNde = &cmdList[201];
p->cmd = 66;
p->action = CMD_PRIOR16;
strcpy(p->cmdName, "fixed");
/* 237: uni */
p = &cmdList[237];
p->index = 237;
p->parent = &cmdList[235];
p->left = &cmdList[238];
p->sib = &cmdList[243];
p->rNde = NULL;
p->cmd = 68;
p->action = CMD_PRIOR17;
strcpy(p->cmdName, "uni");
/* 238: ( */
p = &cmdList[238];
p->index = 238;
p->parent = &cmdList[237];
p->left = &cmdList[239];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 239: digit */
p = &cmdList[239];
p->index = 239;
p->parent = &cmdList[238];
p->left = &cmdList[240];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR19;
strcpy(p->cmdName, "<number>");
/* 240: , */
p = &cmdList[240];
p->index = 240;
p->parent = &cmdList[239];
p->left = &cmdList[241];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 241: digit */
p = &cmdList[241];
p->index = 241;
p->parent = &cmdList[240];
p->left = &cmdList[242];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR20;
strcpy(p->cmdName, "<number>");
/* 242: ) */
p = &cmdList[242];
p->index = 242;
p->parent = &cmdList[241];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 243: exp */
p = &cmdList[243];
p->index = 243;
p->parent = &cmdList[235];
p->left = &cmdList[244];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 67;
p->action = CMD_PRIOR18;
strcpy(p->cmdName, "exp");
/* 244: ( */
p = &cmdList[244];
p->index = 244;
p->parent = &cmdList[243];
p->left = &cmdList[245];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 245: digit */
p = &cmdList[245];
p->index = 245;
p->parent = &cmdList[244];
p->left = &cmdList[246];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR21;
strcpy(p->cmdName, "<number>");
/* 246: ) */
p = &cmdList[246];
p->index = 246;
p->parent = &cmdList[245];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 247: siteratepr */
p = &cmdList[247];
p->index = 247;
p->parent = &cmdList[201];
p->left = &cmdList[248];
p->sib = &cmdList[265];
p->rNde = NULL;
p->cmd = 74;
p->action = -1;
strcpy(p->cmdName, "siteratepr");
/* 248: = */
p = &cmdList[248];
p->index = 248;
p->parent = &cmdList[247];
p->left = &cmdList[249];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 249: fixed */
p = &cmdList[249];
p->index = 249;
p->parent = &cmdList[248];
p->left = NULL;
p->sib = &cmdList[250];
p->rNde = &cmdList[201];
p->cmd = 66;
p->action = CMD_PRIOR22;
strcpy(p->cmdName, "fixed");
/* 250: uni */
p = &cmdList[250];
p->index = 250;
p->parent = &cmdList[248];
p->left = &cmdList[251];
p->sib = &cmdList[256];
p->rNde = NULL;
p->cmd = 68;
p->action = CMD_PRIOR23;
strcpy(p->cmdName, "uni");
/* 251: ( */
p = &cmdList[251];
p->index = 251;
p->parent = &cmdList[250];
p->left = &cmdList[252];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 252: digit */
p = &cmdList[252];
p->index = 252;
p->parent = &cmdList[251];
p->left = &cmdList[253];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR25;
strcpy(p->cmdName, "<number>");
/* 253: , */
p = &cmdList[253];
p->index = 253;
p->parent = &cmdList[252];
p->left = &cmdList[254];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 254: digit */
p = &cmdList[254];
p->index = 254;
p->parent = &cmdList[253];
p->left = &cmdList[255];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR26;
strcpy(p->cmdName, "<number>");
/* 255: ) */
p = &cmdList[255];
p->index = 255;
p->parent = &cmdList[254];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 256: exp */
p = &cmdList[256];
p->index = 256;
p->parent = &cmdList[248];
p->left = &cmdList[257];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 67;
p->action = CMD_PRIOR24;
strcpy(p->cmdName, "exp");
/* 257: ( */
p = &cmdList[257];
p->index = 257;
p->parent = &cmdList[256];
p->left = &cmdList[258];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 258: digit */
p = &cmdList[258];
p->index = 258;
p->parent = &cmdList[257];
p->left = &cmdList[259];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_PRIOR27;
strcpy(p->cmdName, "<number>");
/* 259: ) */
p = &cmdList[259];
p->index = 259;
p->parent = &cmdList[258];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 260: bd */
p = &cmdList[260];
p->index = 260;
p->parent = &cmdList[223];
p->left = &cmdList[310];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 72;
p->action = CMD_PRIOR12;
strcpy(p->cmdName, "bd");
/* 261: all */
p = &cmdList[261];
p->index = 261;
p->parent = &cmdList[106];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[106];
p->cmd = 52;
p->action = CMD_EXCLUDE4;
strcpy(p->cmdName, "all");
/* 262: all */
p = &cmdList[262];
p->index = 262;
p->parent = &cmdList[165];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[165];
p->cmd = 52;
p->action = CMD_INCLUDE4;
strcpy(p->cmdName, "all");
/* 263: all */
p = &cmdList[263];
p->index = 263;
p->parent = &cmdList[170];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[170];
p->cmd = 52;
p->action = CMD_DELETE3;
strcpy(p->cmdName, "all");
/* 264: all */
p = &cmdList[264];
p->index = 264;
p->parent = &cmdList[174];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[174];
p->cmd = 52;
p->action = CMD_RESTORE3;
strcpy(p->cmdName, "all");
/* 265: ; */
p = &cmdList[265];
p->index = 265;
p->parent = &cmdList[201];
p->left = NULL;
p->sib = &cmdList[437];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = -1;
strcpy(p->cmdName, ";");
/* 266: startingtree */
p = &cmdList[266];
p->index = 266;
p->parent = &cmdList[178];
p->left = &cmdList[267];
p->sib = &cmdList[303];
p->rNde = NULL;
p->cmd = 75;
p->action = -1;
strcpy(p->cmdName, "startingtree");
/* 267: = */
p = &cmdList[267];
p->index = 267;
p->parent = &cmdList[266];
p->left = &cmdList[268];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 268: random */
p = &cmdList[268];
p->index = 268;
p->parent = &cmdList[267];
p->left = NULL;
p->sib = &cmdList[269];
p->rNde = &cmdList[178];
p->cmd = 76;
p->action = CMD_MCMC9;
strcpy(p->cmdName, "random");
/* 269: user */
p = &cmdList[269];
p->index = 269;
p->parent = &cmdList[267];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = 77;
p->action = CMD_MCMC9;
strcpy(p->cmdName, "user");
/* 270: usertree */
p = &cmdList[270];
p->index = 270;
p->parent = &cmdList[41];
p->left = &cmdList[271];
p->sib = &cmdList[280];
p->rNde = NULL;
p->cmd = 78;
p->action = -1;
strcpy(p->cmdName, "usertree");
/* 271: = */
p = &cmdList[271];
p->index = 271;
p->parent = &cmdList[270];
p->left = &cmdList[272];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = CMD_TREE;
strcpy(p->cmdName, "=");
/* 272: ( */
p = &cmdList[272];
p->index = 272;
p->parent = &cmdList[271];
p->left = NULL;
p->sib = &cmdList[273];
p->rNde = &cmdList[271];
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = CMD_TREE1;
strcpy(p->cmdName, "(");
/* 273: name */
p = &cmdList[273];
p->index = 273;
p->parent = &cmdList[271];
p->left = NULL;
p->sib = &cmdList[274];
p->rNde = &cmdList[271];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_TREE2;
strcpy(p->cmdName, "<taxon name>");
/* 274: number */
p = &cmdList[274];
p->index = 274;
p->parent = &cmdList[271];
p->left = NULL;
p->sib = &cmdList[275];
p->rNde = &cmdList[271];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_TREE3;
strcpy(p->cmdName, "<taxon number>");
/* 275: ) */
p = &cmdList[275];
p->index = 275;
p->parent = &cmdList[271];
p->left = NULL;
p->sib = &cmdList[276];
p->rNde = &cmdList[271];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = CMD_TREE4;
strcpy(p->cmdName, ")");
/* 276: , */
p = &cmdList[276];
p->index = 276;
p->parent = &cmdList[271];
p->left = NULL;
p->sib = &cmdList[277];
p->rNde = &cmdList[271];
p->cmd = NUMCOMMANDS + COMMA;
p->action = CMD_TREE5;
strcpy(p->cmdName, ",");
/* 277: : */
p = &cmdList[277];
p->index = 277;
p->parent = &cmdList[271];
p->left = &cmdList[279];
p->sib = &cmdList[278];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COLON;
p->action = CMD_TREE6;
strcpy(p->cmdName, ":");
/* 278: ; */
p = &cmdList[278];
p->index = 278;
p->parent = &cmdList[271];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_TREE7;
strcpy(p->cmdName, ";");
/* 279: number */
p = &cmdList[279];
p->index = 279;
p->parent = &cmdList[277];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[271];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_TREE8;
strcpy(p->cmdName, "<branch length>");
/* 280: showtree */
p = &cmdList[280];
p->index = 280;
p->parent = &cmdList[41];
p->left = &cmdList[281];
p->sib = &cmdList[297];
p->rNde = NULL;
p->cmd = 79;
p->action = -1;
strcpy(p->cmdName, "showtree");
/* 281: ; */
p = &cmdList[281];
p->index = 281;
p->parent = &cmdList[280];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SHOWUSERTREE;
strcpy(p->cmdName, ";");
/* 282: enforcecal */
p = &cmdList[282];
p->index = 282;
p->parent = &cmdList[53];
p->left = &cmdList[283];
p->sib = &cmdList[286];
p->rNde = NULL;
p->cmd = 80;
p->action = -1;
strcpy(p->cmdName, "enforcecal");
/* 283: = */
p = &cmdList[283];
p->index = 283;
p->parent = &cmdList[282];
p->left = &cmdList[284];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 284: yes */
p = &cmdList[284];
p->index = 284;
p->parent = &cmdList[283];
p->left = NULL;
p->sib = &cmdList[285];
p->rNde = &cmdList[53];
p->cmd = 17;
p->action = CMD_INIT_ENFORCECAL;
strcpy(p->cmdName, "yes");
/* 285: no */
p = &cmdList[285];
p->index = 285;
p->parent = &cmdList[283];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 18;
p->action = CMD_INIT_ENFORCECAL;
strcpy(p->cmdName, "no");
/* 286: enforcecon */
p = &cmdList[286];
p->index = 286;
p->parent = &cmdList[53];
p->left = &cmdList[287];
p->sib = &cmdList[290];
p->rNde = NULL;
p->cmd = 81;
p->action = -1;
strcpy(p->cmdName, "enforcecon");
/* 287: = */
p = &cmdList[287];
p->index = 287;
p->parent = &cmdList[286];
p->left = &cmdList[288];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 288: yes */
p = &cmdList[288];
p->index = 288;
p->parent = &cmdList[287];
p->left = NULL;
p->sib = &cmdList[289];
p->rNde = &cmdList[53];
p->cmd = 17;
p->action = CMD_INIT_ENFORCECON;
strcpy(p->cmdName, "yes");
/* 289: no */
p = &cmdList[289];
p->index = 289;
p->parent = &cmdList[287];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 18;
p->action = CMD_INIT_ENFORCECON;
strcpy(p->cmdName, "no");
/* 290: inferanc */
p = &cmdList[290];
p->index = 290;
p->parent = &cmdList[53];
p->left = &cmdList[291];
p->sib = &cmdList[294];
p->rNde = NULL;
p->cmd = 82;
p->action = -1;
strcpy(p->cmdName, "inferanc");
/* 291: = */
p = &cmdList[291];
p->index = 291;
p->parent = &cmdList[290];
p->left = &cmdList[292];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 292: yes */
p = &cmdList[292];
p->index = 292;
p->parent = &cmdList[291];
p->left = NULL;
p->sib = &cmdList[293];
p->rNde = &cmdList[53];
p->cmd = 17;
p->action = CMD_INIT_INFERANC;
strcpy(p->cmdName, "yes");
/* 293: no */
p = &cmdList[293];
p->index = 293;
p->parent = &cmdList[291];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 18;
p->action = CMD_INIT_INFERANC;
strcpy(p->cmdName, "no");
/* 294: ncat */
p = &cmdList[294];
p->index = 294;
p->parent = &cmdList[53];
p->left = &cmdList[295];
p->sib = &cmdList[307];
p->rNde = NULL;
p->cmd = 85;
p->action = -1;
strcpy(p->cmdName, "ncat");
/* 295: = */
p = &cmdList[295];
p->index = 295;
p->parent = &cmdList[294];
p->left = &cmdList[296];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 296: digit */
p = &cmdList[296];
p->index = 296;
p->parent = &cmdList[296];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INIT_NCAT;
strcpy(p->cmdName, "<num rate cats");
/* 297: root */
p = &cmdList[297];
p->index = 297;
p->parent = &cmdList[41];
p->left = &cmdList[298];
p->sib = &cmdList[299];
p->rNde = NULL;
p->cmd = 83;
p->action = -1;
strcpy(p->cmdName, "root");
/* 298: ; */
p = &cmdList[298];
p->index = 298;
p->parent = &cmdList[297];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_ROOT_TREE;
strcpy(p->cmdName, ";");
/* 299: deroot */
p = &cmdList[299];
p->index = 299;
p->parent = &cmdList[41];
p->left = &cmdList[300];
p->sib = &cmdList[301];
p->rNde = NULL;
p->cmd = 84;
p->action = -1;
strcpy(p->cmdName, "deroot");
/* 300: ; */
p = &cmdList[300];
p->index = 300;
p->parent = &cmdList[299];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_DEROOT_TREE;
strcpy(p->cmdName, ";");
/* 301: shownodes */
p = &cmdList[301];
p->index = 301;
p->parent = &cmdList[41];
p->left = &cmdList[302];
p->sib = &cmdList[317];
p->rNde = NULL;
p->cmd = 86;
p->action = -1;
strcpy(p->cmdName, "shownodes");
/* 302: ; */
p = &cmdList[302];
p->index = 302;
p->parent = &cmdList[301];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SHOWNODES;
strcpy(p->cmdName, ";");
/* 303: savebrlens */
p = &cmdList[303];
p->index = 303;
p->parent = &cmdList[178];
p->left = &cmdList[304];
p->sib = &cmdList[411];
p->rNde = NULL;
p->cmd = 87;
p->action = -1;
strcpy(p->cmdName, "savebrlens");
/* 304: = */
p = &cmdList[304];
p->index = 304;
p->parent = &cmdList[303];
p->left = &cmdList[305];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 305: yes */
p = &cmdList[305];
p->index = 305;
p->parent = &cmdList[304];
p->left = NULL;
p->sib = &cmdList[306];
p->rNde = &cmdList[178];
p->cmd = 17;
p->action = CMD_SAVEBRLENS;
strcpy(p->cmdName, "yes");
/* 306: no */
p = &cmdList[306];
p->index = 306;
p->parent = &cmdList[304];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = 18;
p->action = CMD_SAVEBRLENS;
strcpy(p->cmdName, "no");
/* 307: seqerror */
p = &cmdList[307];
p->index = 307;
p->parent = &cmdList[53];
p->left = &cmdList[308];
p->sib = &cmdList[414];
p->rNde = NULL;
p->cmd = 88;
p->action = -1;
strcpy(p->cmdName, "seqerror");
/* 308: = */
p = &cmdList[308];
p->index = 308;
p->parent = &cmdList[307];
p->left = &cmdList[309];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 309: digit */
p = &cmdList[309];
p->index = 309;
p->parent = &cmdList[308];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_SEQ_ERROR;
strcpy(p->cmdName, "<number>");
/* 310: ( */
p = &cmdList[310];
p->index = 310;
p->parent = &cmdList[260];
p->left = &cmdList[311];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 311: digit */
p = &cmdList[311];
p->index = 311;
p->parent = &cmdList[310];
p->left = &cmdList[312];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_SP_RATE;
strcpy(p->cmdName, "<speciation rate>");
/* 312: , */
p = &cmdList[312];
p->index = 312;
p->parent = &cmdList[311];
p->left = &cmdList[313];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 313: digit */
p = &cmdList[313];
p->index = 313;
p->parent = &cmdList[312];
p->left = &cmdList[314];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_EX_RATE;
strcpy(p->cmdName, "<extinction rate>");
/* 314: , */
p = &cmdList[314];
p->index = 314;
p->parent = &cmdList[313];
p->left = &cmdList[315];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 315: digit */
p = &cmdList[315];
p->index = 315;
p->parent = &cmdList[314];
p->left = &cmdList[316];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_SAMP_FRAC;
strcpy(p->cmdName, "<sample fraction>");
/* 316: ) */
p = &cmdList[316];
p->index = 316;
p->parent = &cmdList[315];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 317: sumt */
p = &cmdList[317];
p->index = 317;
p->parent = &cmdList[41];
p->left = &cmdList[318];
p->sib = &cmdList[325];
p->rNde = NULL;
p->cmd = 89;
p->action = -1;
strcpy(p->cmdName, "sumt");
/* 318: filename */
p = &cmdList[318];
p->index = 318;
p->parent = &cmdList[317];
p->left = &cmdList[319];
p->sib = &cmdList[321];
p->rNde = NULL;
p->cmd = 63;
p->action = -1;
strcpy(p->cmdName, "filename");
/* 319: = */
p = &cmdList[319];
p->index = 319;
p->parent = &cmdList[318];
p->left = &cmdList[320];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 320: name */
p = &cmdList[320];
p->index = 320;
p->parent = &cmdList[319];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[317];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_SUMT_FILENAME;
strcpy(p->cmdName, "<file name>");
/* 321: burnin */
p = &cmdList[321];
p->index = 321;
p->parent = &cmdList[317];
p->left = &cmdList[322];
p->sib = &cmdList[324];
p->rNde = NULL;
p->cmd = 91;
p->action = -1;
strcpy(p->cmdName, "burnin");
/* 322: = */
p = &cmdList[322];
p->index = 322;
p->parent = &cmdList[321];
p->left = &cmdList[323];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 323: digit */
p = &cmdList[323];
p->index = 323;
p->parent = &cmdList[322];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[317];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SUMT_BURN;
strcpy(p->cmdName, "<burn in>");
/* 324: ; */
p = &cmdList[324];
p->index = 324;
p->parent = &cmdList[317];
p->left = NULL;
p->sib = &cmdList[355];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SUMT_READFILE;
strcpy(p->cmdName, ";");
/* 325: sump */
p = &cmdList[325];
p->index = 325;
p->parent = &cmdList[41];
p->left = &cmdList[326];
p->sib = &cmdList[371];
p->rNde = NULL;
p->cmd = 90;
p->action = -1;
strcpy(p->cmdName, "sump");
/* 326: filename */
p = &cmdList[326];
p->index = 326;
p->parent = &cmdList[325];
p->left = &cmdList[327];
p->sib = &cmdList[329];
p->rNde = NULL;
p->cmd = 63;
p->action = -1;
strcpy(p->cmdName, "filename");
/* 327: = */
p = &cmdList[327];
p->index = 327;
p->parent = &cmdList[326];
p->left = &cmdList[328];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 328: name */
p = &cmdList[328];
p->index = 328;
p->parent = &cmdList[327];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[325];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_SUMP_FILENAME;
strcpy(p->cmdName, "<file name>");
/* 329: burnin */
p = &cmdList[329];
p->index = 329;
p->parent = &cmdList[325];
p->left = &cmdList[330];
p->sib = &cmdList[332];
p->rNde = NULL;
p->cmd = 91;
p->action = -1;
strcpy(p->cmdName, "burnin");
/* 330: = */
p = &cmdList[330];
p->index = 330;
p->parent = &cmdList[329];
p->left = &cmdList[331];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 331: digit */
p = &cmdList[331];
p->index = 331;
p->parent = &cmdList[330];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[325];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SUMP_BURN;
strcpy(p->cmdName, "<burn in>");
/* 332: ; */
p = &cmdList[332];
p->index = 332;
p->parent = &cmdList[325];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SUMP_READFILE;
strcpy(p->cmdName, ";");
/* 333: trees */
p = &cmdList[333];
p->index = 333;
p->parent = &cmdList[3];
p->left = &cmdList[334];
p->sib = &cmdList[359];
p->rNde = NULL;
p->cmd = 5;
p->action = -1;
strcpy(p->cmdName, "trees");
/* 334: ; */
p = &cmdList[334];
p->index = 334;
p->parent = &cmdList[333];
p->left = &cmdList[335];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_INIT_TREE_BLK;
strcpy(p->cmdName, ";");
/* 335: end */
p = &cmdList[335];
p->index = 335;
p->parent = &cmdList[334];
p->left = &cmdList[336];
p->sib = &cmdList[337];
p->rNde = NULL;
p->cmd = 2;
p->action = -1;
strcpy(p->cmdName, "end");
/* 336: ; */
p = &cmdList[336];
p->index = 336;
p->parent = &cmdList[335];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[0];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SUM_TREE_END;
strcpy(p->cmdName, ";");
/* 337: translate */
p = &cmdList[337];
p->index = 337;
p->parent = &cmdList[334];
p->left = &cmdList[338];
p->sib = &cmdList[343];
p->rNde = NULL;
p->cmd = 93;
p->action = CMD_TRANS_INIT;
strcpy(p->cmdName, "translate");
/* 338: number */
p = &cmdList[338];
p->index = 338;
p->parent = &cmdList[337];
p->left = &cmdList[340];
p->sib = &cmdList[339];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_TRANS_NEW_NM;
strcpy(p->cmdName, "<number>");
/* 339: name */
p = &cmdList[339];
p->index = 339;
p->parent = &cmdList[337];
p->left = &cmdList[340];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_TRANS_NEW_NM;
strcpy(p->cmdName, "<name>");
/* 340: name */
p = &cmdList[340];
p->index = 340;
p->parent = &cmdList[338];
p->left = &cmdList[341];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_TRANS_OLD_NM;
strcpy(p->cmdName, "<taxon name>");
/* 341: , */
p = &cmdList[341];
p->index = 341;
p->parent = &cmdList[340];
p->left = NULL;
p->sib = &cmdList[342];
p->rNde = &cmdList[337];
p->cmd = NUMCOMMANDS + COMMA;
p->action = CMD_TRANS_COMMA;
strcpy(p->cmdName, ",");
/* 342: ; */
p = &cmdList[342];
p->index = 342;
p->parent = &cmdList[340];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[334];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_TRANS_END;
strcpy(p->cmdName, ";");
/* 343: tree */
p = &cmdList[343];
p->index = 343;
p->parent = &cmdList[334];
p->left = &cmdList[344];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 92;
p->action = -1;
strcpy(p->cmdName, "tree");
/* 344: name */
p = &cmdList[344];
p->index = 344;
p->parent = &cmdList[343];
p->left = &cmdList[346];
p->sib = &cmdList[345];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = -1;
strcpy(p->cmdName, "<tree name>");
/* 345: number */
p = &cmdList[345];
p->index = 345;
p->parent = &cmdList[343];
p->left = &cmdList[346];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = -1;
strcpy(p->cmdName, "<tree number>");
/* 346: = */
p = &cmdList[346];
p->index = 346;
p->parent = &cmdList[344];
p->left = &cmdList[347];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = CMD_SUM_TREE;
strcpy(p->cmdName, "=");
/* 347: ( */
p = &cmdList[347];
p->index = 347;
p->parent = &cmdList[346];
p->left = NULL;
p->sib = &cmdList[348];
p->rNde = &cmdList[346];
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = CMD_SUM_TREE1;
strcpy(p->cmdName, "(");
/* 348: name */
p = &cmdList[348];
p->index = 348;
p->parent = &cmdList[346];
p->left = NULL;
p->sib = &cmdList[349];
p->rNde = &cmdList[346];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_SUM_TREE2;
strcpy(p->cmdName, "<taxon name>");
/* 349: number */
p = &cmdList[349];
p->index = 349;
p->parent = &cmdList[346];
p->left = NULL;
p->sib = &cmdList[350];
p->rNde = &cmdList[346];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SUM_TREE3;
strcpy(p->cmdName, "<taxon number>");
/* 350: ) */
p = &cmdList[350];
p->index = 350;
p->parent = &cmdList[346];
p->left = NULL;
p->sib = &cmdList[351];
p->rNde = &cmdList[346];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = CMD_SUM_TREE4;
strcpy(p->cmdName, ")");
/* 351: , */
p = &cmdList[351];
p->index = 351;
p->parent = &cmdList[346];
p->left = NULL;
p->sib = &cmdList[352];
p->rNde = &cmdList[346];
p->cmd = NUMCOMMANDS + COMMA;
p->action = CMD_SUM_TREE5;
strcpy(p->cmdName, ",");
/* 352: : */
p = &cmdList[352];
p->index = 352;
p->parent = &cmdList[346];
p->left = &cmdList[354];
p->sib = &cmdList[353];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COLON;
p->action = CMD_SUM_TREE6;
strcpy(p->cmdName, ":");
/* 353: ; */
p = &cmdList[353];
p->index = 353;
p->parent = &cmdList[346];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[334];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SUM_TREE7;
strcpy(p->cmdName, ";");
/* 354: digit */
p = &cmdList[354];
p->index = 354;
p->parent = &cmdList[352];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[346];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SUM_TREE8;
strcpy(p->cmdName, "<branch length>");
/* 355: contype */
p = &cmdList[355];
p->index = 355;
p->parent = &cmdList[317];
p->left = &cmdList[356];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 94;
p->action = -1;
strcpy(p->cmdName, "contype");
/* 356: = */
p = &cmdList[356];
p->index = 356;
p->parent = &cmdList[355];
p->left = &cmdList[357];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 357: halfcompat */
p = &cmdList[357];
p->index = 357;
p->parent = &cmdList[356];
p->left = NULL;
p->sib = &cmdList[358];
p->rNde = &cmdList[317];
p->cmd = 95;
p->action = CMD_SUMT_HALFCOMP;
strcpy(p->cmdName, "halfcompat");
/* 358: allcompat */
p = &cmdList[358];
p->index = 358;
p->parent = &cmdList[356];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[317];
p->cmd = 96;
p->action = CMD_SUMT_ALLCOMP;
strcpy(p->cmdName, "allcompat");
/* 359: bayesparams */
p = &cmdList[359];
p->index = 359;
p->parent = &cmdList[3];
p->left = &cmdList[360];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 97;
p->action = -1;
strcpy(p->cmdName, "bayesparams");
/* 360: ; */
p = &cmdList[360];
p->index = 360;
p->parent = &cmdList[359];
p->left = &cmdList[361];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SUM_PARM1;
strcpy(p->cmdName, ";");
/* 361: end */
p = &cmdList[361];
p->index = 361;
p->parent = &cmdList[360];
p->left = &cmdList[362];
p->sib = &cmdList[363];
p->rNde = NULL;
p->cmd = 2;
p->action = -1;
strcpy(p->cmdName, "end");
/* 362: ; */
p = &cmdList[362];
p->index = 362;
p->parent = &cmdList[361];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[0];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SUM_PARM2;
strcpy(p->cmdName, ";");
/* 363: header */
p = &cmdList[363];
p->index = 363;
p->parent = &cmdList[360];
p->left = &cmdList[364];
p->sib = &cmdList[367];
p->rNde = NULL;
p->cmd = 98;
p->action = -1;
strcpy(p->cmdName, "header");
/* 364: <name> */
p = &cmdList[364];
p->index = 364;
p->parent = &cmdList[363];
p->left = &cmdList[365];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_SUM_PARM3;
strcpy(p->cmdName, "<name>");
/* 365: , */
p = &cmdList[365];
p->index = 365;
p->parent = &cmdList[364];
p->left = NULL;
p->sib = &cmdList[366];
p->rNde = &cmdList[363];
p->cmd = NUMCOMMANDS + COMMA;
p->action = CMD_SUM_PARM4;
strcpy(p->cmdName, ",");
/* 366: ; */
p = &cmdList[366];
p->index = 366;
p->parent = &cmdList[364];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[360];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SUM_PARM5;
strcpy(p->cmdName, ";");
/* 367: data */
p = &cmdList[367];
p->index = 367;
p->parent = &cmdList[360];
p->left = &cmdList[368];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 4;
p->action = CMD_SUM_PARM6;
strcpy(p->cmdName, "data");
/* 368: number */
p = &cmdList[368];
p->index = 368;
p->parent = &cmdList[367];
p->left = &cmdList[369];
p->sib = &cmdList[465];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SUM_PARM7;
strcpy(p->cmdName, "<number>");
/* 369: , */
p = &cmdList[369];
p->index = 369;
p->parent = &cmdList[368];
p->left = NULL;
p->sib = &cmdList[370];
p->rNde = &cmdList[367];
p->cmd = NUMCOMMANDS + COMMA;
p->action = CMD_SUM_PARM8;
strcpy(p->cmdName, ",");
/* 370: ; */
p = &cmdList[370];
p->index = 370;
p->parent = &cmdList[368];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[360];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SUM_PARM9;
strcpy(p->cmdName, ";");
/* 371: set */
p = &cmdList[371];
p->index = 371;
p->parent = &cmdList[41];
p->left = &cmdList[372];
p->sib = &cmdList[377];
p->rNde = NULL;
p->cmd = 99;
p->action = -1;
strcpy(p->cmdName, "set");
/* 372: ; */
p = &cmdList[372];
p->index = 372;
p->parent = &cmdList[371];
p->left = NULL;
p->sib = &cmdList[373];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = -1;
strcpy(p->cmdName, ";");
/* 373: autoclose */
p = &cmdList[373];
p->index = 373;
p->parent = &cmdList[371];
p->left = &cmdList[374];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 100;
p->action = -1;
strcpy(p->cmdName, "autoclose");
/* 374: = */
p = &cmdList[374];
p->index = 374;
p->parent = &cmdList[373];
p->left = &cmdList[375];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 375: yes */
p = &cmdList[375];
p->index = 375;
p->parent = &cmdList[374];
p->left = NULL;
p->sib = &cmdList[376];
p->rNde = &cmdList[371];
p->cmd = 17;
p->action = CMD_AUTOCLOSE1;
strcpy(p->cmdName, "yes");
/* 376: no */
p = &cmdList[376];
p->index = 376;
p->parent = &cmdList[374];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[371];
p->cmd = 18;
p->action = CMD_AUTOCLOSE2;
strcpy(p->cmdName, "no");
/* 377: mcmcp */
p = &cmdList[377];
p->index = 377;
p->parent = &cmdList[41];
p->left = &cmdList[378];
p->sib = &cmdList[499];
p->rNde = NULL;
p->cmd = 101;
p->action = CMD_MCMCP;
strcpy(p->cmdName, "mcmcp");
/* 378: seed */
p = &cmdList[378];
p->index = 378;
p->parent = &cmdList[377];
p->left = &cmdList[379];
p->sib = &cmdList[381];
p->rNde = NULL;
p->cmd = 57;
p->action = -1;
strcpy(p->cmdName, "seed");
/* 379: = */
p = &cmdList[379];
p->index = 379;
p->parent = &cmdList[378];
p->left = &cmdList[380];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 380: digit */
p = &cmdList[380];
p->index = 380;
p->parent = &cmdList[379];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC1;
strcpy(p->cmdName, "<number>");
/* 381: ngen */
p = &cmdList[381];
p->index = 381;
p->parent = &cmdList[377];
p->left = &cmdList[382];
p->sib = &cmdList[384];
p->rNde = NULL;
p->cmd = 58;
p->action = -1;
strcpy(p->cmdName, "ngen");
/* 382: = */
p = &cmdList[382];
p->index = 382;
p->parent = &cmdList[381];
p->left = &cmdList[383];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 383: digit */
p = &cmdList[383];
p->index = 383;
p->parent = &cmdList[382];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC2;
strcpy(p->cmdName, "<number>");
/* 384: samplefreq */
p = &cmdList[384];
p->index = 384;
p->parent = &cmdList[377];
p->left = &cmdList[385];
p->sib = &cmdList[387];
p->rNde = NULL;
p->cmd = 59;
p->action = -1;
strcpy(p->cmdName, "samplefreq");
/* 385: = */
p = &cmdList[385];
p->index = 385;
p->parent = &cmdList[384];
p->left = &cmdList[386];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 386: digit */
p = &cmdList[386];
p->index = 386;
p->parent = &cmdList[385];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC3;
strcpy(p->cmdName, "<number>");
/* 387: printfreq */
p = &cmdList[387];
p->index = 387;
p->parent = &cmdList[377];
p->left = &cmdList[388];
p->sib = &cmdList[390];
p->rNde = NULL;
p->cmd = 60;
p->action = -1;
strcpy(p->cmdName, "printfreq");
/* 388: = */
p = &cmdList[388];
p->index = 388;
p->parent = &cmdList[387];
p->left = &cmdList[389];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 389: digit */
p = &cmdList[389];
p->index = 389;
p->parent = &cmdList[388];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC4;
strcpy(p->cmdName, "<number>");
/* 390: nchains */
p = &cmdList[390];
p->index = 390;
p->parent = &cmdList[377];
p->left = &cmdList[391];
p->sib = &cmdList[393];
p->rNde = NULL;
p->cmd = 61;
p->action = -1;
strcpy(p->cmdName, "nchains");
/* 391: = */
p = &cmdList[391];
p->index = 391;
p->parent = &cmdList[390];
p->left = &cmdList[392];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 392: digit */
p = &cmdList[392];
p->index = 392;
p->parent = &cmdList[391];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC5;
strcpy(p->cmdName, "<number>");
/* 393: temp */
p = &cmdList[393];
p->index = 393;
p->parent = &cmdList[377];
p->left = &cmdList[394];
p->sib = &cmdList[396];
p->rNde = NULL;
p->cmd = 62;
p->action = -1;
strcpy(p->cmdName, "temp");
/* 394: = */
p = &cmdList[394];
p->index = 394;
p->parent = &cmdList[393];
p->left = &cmdList[395];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 395: digit */
p = &cmdList[395];
p->index = 395;
p->parent = &cmdList[394];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_MCMC6;
strcpy(p->cmdName, "<number>");
/* 396: filename */
p = &cmdList[396];
p->index = 396;
p->parent = &cmdList[377];
p->left = &cmdList[397];
p->sib = &cmdList[399];
p->rNde = NULL;
p->cmd = 63;
p->action = -1;
strcpy(p->cmdName, "filename");
/* 397: = */
p = &cmdList[397];
p->index = 397;
p->parent = &cmdList[396];
p->left = &cmdList[398];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 398: alpha */
p = &cmdList[398];
p->index = 398;
p->parent = &cmdList[397];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_MCMC7;
strcpy(p->cmdName, "<file name>");
/* 399: ; */
p = &cmdList[399];
p->index = 399;
p->parent = &cmdList[377];
p->left = NULL;
p->sib = &cmdList[400];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = -1;
strcpy(p->cmdName, ";");
/* 400: startingtree */
p = &cmdList[400];
p->index = 400;
p->parent = &cmdList[377];
p->left = &cmdList[401];
p->sib = &cmdList[404];
p->rNde = NULL;
p->cmd = 75;
p->action = -1;
strcpy(p->cmdName, "startingtree");
/* 401: = */
p = &cmdList[401];
p->index = 401;
p->parent = &cmdList[400];
p->left = &cmdList[402];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 402: random */
p = &cmdList[402];
p->index = 402;
p->parent = &cmdList[401];
p->left = NULL;
p->sib = &cmdList[403];
p->rNde = &cmdList[377];
p->cmd = 76;
p->action = CMD_MCMC9;
strcpy(p->cmdName, "random");
/* 403: user */
p = &cmdList[403];
p->index = 403;
p->parent = &cmdList[401];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = 77;
p->action = CMD_MCMC9;
strcpy(p->cmdName, "user");
/* 404: savebrlens */
p = &cmdList[404];
p->index = 404;
p->parent = &cmdList[377];
p->left = &cmdList[405];
p->sib = &cmdList[408];
p->rNde = NULL;
p->cmd = 87;
p->action = -1;
strcpy(p->cmdName, "savebrlens");
/* 405: = */
p = &cmdList[405];
p->index = 405;
p->parent = &cmdList[404];
p->left = &cmdList[406];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 406: yes */
p = &cmdList[406];
p->index = 406;
p->parent = &cmdList[405];
p->left = NULL;
p->sib = &cmdList[407];
p->rNde = &cmdList[377];
p->cmd = 17;
p->action = CMD_SAVEBRLENS;
strcpy(p->cmdName, "yes");
/* 407: no */
p = &cmdList[407];
p->index = 407;
p->parent = &cmdList[405];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = 18;
p->action = CMD_SAVEBRLENS;
strcpy(p->cmdName, "no");
/* 408: nperts */
p = &cmdList[408];
p->index = 408;
p->parent = &cmdList[377];
p->left = &cmdList[409];
p->sib = &cmdList[555];
p->rNde = NULL;
p->cmd = 102;
p->action = -1;
strcpy(p->cmdName, "nperts");
/* 409: = */
p = &cmdList[409];
p->index = 409;
p->parent = &cmdList[408];
p->left = &cmdList[410];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 410: digit */
p = &cmdList[410];
p->index = 410;
p->parent = &cmdList[409];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_NPERB;
strcpy(p->cmdName, "<number>");
/* 411: nperts */
p = &cmdList[411];
p->index = 411;
p->parent = &cmdList[178];
p->left = &cmdList[412];
p->sib = &cmdList[545];
p->rNde = NULL;
p->cmd = 102;
p->action = -1;
strcpy(p->cmdName, "nperts");
/* 412: = */
p = &cmdList[412];
p->index = 412;
p->parent = &cmdList[411];
p->left = &cmdList[413];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 413: digit */
p = &cmdList[413];
p->index = 413;
p->parent = &cmdList[412];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_NPERB;
strcpy(p->cmdName, "<number>");
/* 414: aamodel */
p = &cmdList[414];
p->index = 414;
p->parent = &cmdList[53];
p->left = &cmdList[415];
p->sib = &cmdList[421];
p->rNde = NULL;
p->cmd = 103;
p->action = -1;
strcpy(p->cmdName, "aamodel");
/* 415: = */
p = &cmdList[415];
p->index = 415;
p->parent = &cmdList[414];
p->left = &cmdList[416];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 416: poisson */
p = &cmdList[416];
p->index = 416;
p->parent = &cmdList[415];
p->left = NULL;
p->sib = &cmdList[417];
p->rNde = &cmdList[53];
p->cmd = 104;
p->action = CMD_SET_AAMODEL1;
strcpy(p->cmdName, "poisson");
/* 417: equalin */
p = &cmdList[417];
p->index = 417;
p->parent = &cmdList[415];
p->left = NULL;
p->sib = &cmdList[418];
p->rNde = &cmdList[53];
p->cmd = 105;
p->action = CMD_SET_AAMODEL2;
strcpy(p->cmdName, "equalin");
/* 418: jones */
p = &cmdList[418];
p->index = 418;
p->parent = &cmdList[415];
p->left = NULL;
p->sib = &cmdList[419];
p->rNde = &cmdList[53];
p->cmd = 106;
p->action = CMD_SET_AAMODEL3;
strcpy(p->cmdName, "jones");
/* 419: dayhoff */
p = &cmdList[419];
p->index = 419;
p->parent = &cmdList[415];
p->left = NULL;
p->sib = &cmdList[420];
p->rNde = &cmdList[53];
p->cmd = 107;
p->action = CMD_SET_AAMODEL4;
strcpy(p->cmdName, "dayhoff");
/* 420: gtr */
p = &cmdList[420];
p->index = 420;
p->parent = &cmdList[415];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 108;
p->action = CMD_SET_AAMODEL5;
strcpy(p->cmdName, "gtr");
/* 421: ancfile */
p = &cmdList[421];
p->index = 421;
p->parent = &cmdList[53];
p->left = &cmdList[422];
p->sib = &cmdList[425];
p->rNde = NULL;
p->cmd = 110;
p->action = -1;
strcpy(p->cmdName, "ancfile");
/* 422: = */
p = &cmdList[422];
p->index = 422;
p->parent = &cmdList[421];
p->left = &cmdList[423];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 423: yes */
p = &cmdList[423];
p->index = 423;
p->parent = &cmdList[422];
p->left = NULL;
p->sib = &cmdList[424];
p->rNde = &cmdList[53];
p->cmd = 17;
p->action = CMD_SET_ANCFILE1;
strcpy(p->cmdName, "yes");
/* 424: no */
p = &cmdList[424];
p->index = 424;
p->parent = &cmdList[422];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 18;
p->action = CMD_SET_ANCFILE2;
strcpy(p->cmdName, "no");
/* 425: enforcecodon */
p = &cmdList[425];
p->index = 425;
p->parent = &cmdList[53];
p->left = &cmdList[426];
p->sib = &cmdList[429];
p->rNde = NULL;
p->cmd = 111;
p->action = -1;
strcpy(p->cmdName, "enforcecodon");
/* 426: = */
p = &cmdList[426];
p->index = 426;
p->parent = &cmdList[425];
p->left = &cmdList[427];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 427: yes */
p = &cmdList[427];
p->index = 427;
p->parent = &cmdList[426];
p->left = NULL;
p->sib = &cmdList[428];
p->rNde = &cmdList[53];
p->cmd = 17;
p->action = CMD_SET_CODON1;
strcpy(p->cmdName, "yes");
/* 428: no */
p = &cmdList[428];
p->index = 428;
p->parent = &cmdList[426];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 18;
p->action = CMD_SET_CODON2;
strcpy(p->cmdName, "no");
/* 429: omegavar */
p = &cmdList[429];
p->index = 429;
p->parent = &cmdList[53];
p->left = &cmdList[430];
p->sib = &cmdList[433];
p->rNde = NULL;
p->cmd = 112;
p->action = -1;
strcpy(p->cmdName, "omegavar");
/* 430: = */
p = &cmdList[430];
p->index = 430;
p->parent = &cmdList[429];
p->left = &cmdList[431];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 431: equal */
p = &cmdList[431];
p->index = 431;
p->parent = &cmdList[430];
p->left = NULL;
p->sib = &cmdList[432];
p->rNde = &cmdList[53];
p->cmd = 28;
p->action = CMD_SET_OMEGAVAR1;
strcpy(p->cmdName, "equal");
/* 432: ny98 */
p = &cmdList[432];
p->index = 432;
p->parent = &cmdList[430];
p->left = NULL;
p->sib = &cmdList[463];
p->rNde = &cmdList[53];
p->cmd = 113;
p->action = CMD_SET_OMEGAVAR2;
strcpy(p->cmdName, "ny98");
/* 433: omega */
p = &cmdList[433];
p->index = 433;
p->parent = &cmdList[53];
p->left = &cmdList[434];
p->sib = &cmdList[450];
p->rNde = NULL;
p->cmd = 114;
p->action = -1;
strcpy(p->cmdName, "omega");
/* 434: = */
p = &cmdList[434];
p->index = 434;
p->parent = &cmdList[433];
p->left = &cmdList[435];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 435: number */
p = &cmdList[435];
p->index = 435;
p->parent = &cmdList[434];
p->left = NULL;
p->sib = &cmdList[436];
p->rNde = &cmdList[53];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_OMEGA;
strcpy(p->cmdName, "<number>");
/* 436: estimate */
p = &cmdList[436];
p->index = 436;
p->parent = &cmdList[434];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 37;
p->action = CMD_SET_OMEGA;
strcpy(p->cmdName, "estimate");
/* 437: omegapr */
p = &cmdList[437];
p->index = 437;
p->parent = &cmdList[201];
p->left = &cmdList[438];
p->sib = &cmdList[473];
p->rNde = NULL;
p->cmd = 109;
p->action = -1;
strcpy(p->cmdName, "omegapr");
/* 438: = */
p = &cmdList[438];
p->index = 438;
p->parent = &cmdList[437];
p->left = &cmdList[439];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 439: fixed */
p = &cmdList[439];
p->index = 439;
p->parent = &cmdList[438];
p->left = NULL;
p->sib = &cmdList[440];
p->rNde = &cmdList[201];
p->cmd = 66;
p->action = CMD_OMEGAPR1;
strcpy(p->cmdName, "fixed");
/* 440: uni */
p = &cmdList[440];
p->index = 440;
p->parent = &cmdList[438];
p->left = &cmdList[441];
p->sib = &cmdList[446];
p->rNde = NULL;
p->cmd = 68;
p->action = CMD_OMEGAPR2;
strcpy(p->cmdName, "uni");
/* 441: ( */
p = &cmdList[441];
p->index = 441;
p->parent = &cmdList[440];
p->left = &cmdList[442];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 442: digit */
p = &cmdList[442];
p->index = 442;
p->parent = &cmdList[441];
p->left = &cmdList[443];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = -1;
strcpy(p->cmdName, "<number>");
/* 443: , */
p = &cmdList[443];
p->index = 443;
p->parent = &cmdList[442];
p->left = &cmdList[444];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 444: digit */
p = &cmdList[444];
p->index = 444;
p->parent = &cmdList[443];
p->left = &cmdList[445];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = -1;
strcpy(p->cmdName, "<number>");
/* 445: ) */
p = &cmdList[445];
p->index = 445;
p->parent = &cmdList[444];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 446: exp */
p = &cmdList[446];
p->index = 446;
p->parent = &cmdList[438];
p->left = &cmdList[447];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 67;
p->action = CMD_OMEGAPR5;
strcpy(p->cmdName, "exp");
/* 447: ( */
p = &cmdList[447];
p->index = 447;
p->parent = &cmdList[446];
p->left = &cmdList[448];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 448: digit */
p = &cmdList[448];
p->index = 448;
p->parent = &cmdList[447];
p->left = &cmdList[449];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = -1;
strcpy(p->cmdName, "<number>");
/* 449: ) */
p = &cmdList[449];
p->index = 449;
p->parent = &cmdList[448];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 450: code */
p = &cmdList[450];
p->index = 450;
p->parent = &cmdList[53];
p->left = &cmdList[451];
p->sib = &cmdList[458];
p->rNde = NULL;
p->cmd = 115;
p->action = -1;
strcpy(p->cmdName, "code");
/* 451: = */
p = &cmdList[451];
p->index = 451;
p->parent = &cmdList[450];
p->left = &cmdList[452];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 452: universal */
p = &cmdList[452];
p->index = 452;
p->parent = &cmdList[451];
p->left = NULL;
p->sib = &cmdList[453];
p->rNde = &cmdList[53];
p->cmd = 116;
p->action = CMD_SET_CODE;
strcpy(p->cmdName, "universal");
/* 453: vertmt */
p = &cmdList[453];
p->index = 453;
p->parent = &cmdList[451];
p->left = NULL;
p->sib = &cmdList[454];
p->rNde = &cmdList[53];
p->cmd = 117;
p->action = CMD_SET_CODE;
strcpy(p->cmdName, "vertmt");
/* 454: mycoplasma */
p = &cmdList[454];
p->index = 454;
p->parent = &cmdList[451];
p->left = NULL;
p->sib = &cmdList[455];
p->rNde = &cmdList[53];
p->cmd = 118;
p->action = CMD_SET_CODE;
strcpy(p->cmdName, "mycoplasma");
/* 455: yeast */
p = &cmdList[455];
p->index = 455;
p->parent = &cmdList[451];
p->left = NULL;
p->sib = &cmdList[456];
p->rNde = &cmdList[53];
p->cmd = 119;
p->action = CMD_SET_CODE;
strcpy(p->cmdName, "yeast");
/* 456: ciliates */
p = &cmdList[456];
p->index = 456;
p->parent = &cmdList[451];
p->left = NULL;
p->sib = &cmdList[457];
p->rNde = &cmdList[53];
p->cmd = 120;
p->action = CMD_SET_CODE;
strcpy(p->cmdName, "ciliates");
/* 457: metmt */
p = &cmdList[457];
p->index = 457;
p->parent = &cmdList[451];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 121;
p->action = CMD_SET_CODE;
strcpy(p->cmdName, "metmt");
/* 458: inferpossel */
p = &cmdList[458];
p->index = 458;
p->parent = &cmdList[53];
p->left = &cmdList[459];
p->sib = &cmdList[469];
p->rNde = NULL;
p->cmd = 122;
p->action = -1;
strcpy(p->cmdName, "inferpossel");
/* 459: = */
p = &cmdList[459];
p->index = 459;
p->parent = &cmdList[458];
p->left = &cmdList[460];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 460: yes */
p = &cmdList[460];
p->index = 460;
p->parent = &cmdList[459];
p->left = NULL;
p->sib = &cmdList[461];
p->rNde = &cmdList[53];
p->cmd = 17;
p->action = CMD_INFERSEL_YES;
strcpy(p->cmdName, "yes");
/* 461: no */
p = &cmdList[461];
p->index = 461;
p->parent = &cmdList[459];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 18;
p->action = CMD_INFERSEL_NO;
strcpy(p->cmdName, "no");
/* 462: adgamma */
p = &cmdList[462];
p->index = 462;
p->parent = &cmdList[58];
p->left = NULL;
p->sib = &cmdList[486];
p->rNde = &cmdList[53];
p->cmd = 123;
p->action = CMD_SET_RATES;
strcpy(p->cmdName, "adgamma");
/* 463: ac1ny98 */
p = &cmdList[463];
p->index = 463;
p->parent = &cmdList[430];
p->left = NULL;
p->sib = &cmdList[464];
p->rNde = &cmdList[53];
p->cmd = 124;
p->action = CMD_SET_OMEGAVAR3;
strcpy(p->cmdName, "ac1ny98");
/* 464: ac2ny98 */
p = &cmdList[464];
p->index = 464;
p->parent = &cmdList[430];
p->left = NULL;
p->sib = &cmdList[497];
p->rNde = &cmdList[53];
p->cmd = 125;
p->action = CMD_SET_OMEGAVAR4;
strcpy(p->cmdName, "ac2ny98");
/* 465: - */
p = &cmdList[465];
p->index = 465;
p->parent = &cmdList[367];
p->left = &cmdList[466];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + DASH;
p->action = -1;
strcpy(p->cmdName, "-");
/* 466: number */
p = &cmdList[466];
p->index = 466;
p->parent = &cmdList[465];
p->left = &cmdList[467];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SUM_PARM10;
strcpy(p->cmdName, "<number>");
/* 467: , */
p = &cmdList[467];
p->index = 467;
p->parent = &cmdList[466];
p->left = NULL;
p->sib = &cmdList[468];
p->rNde = &cmdList[367];
p->cmd = NUMCOMMANDS + COMMA;
p->action = CMD_SUM_PARM8;
strcpy(p->cmdName, ",");
/* 468: ; */
p = &cmdList[468];
p->index = 468;
p->parent = &cmdList[466];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[360];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SUM_PARM9;
strcpy(p->cmdName, ";");
/* 469: lag */
p = &cmdList[469];
p->index = 469;
p->parent = &cmdList[53];
p->left = &cmdList[470];
p->sib = &cmdList[490];
p->rNde = NULL;
p->cmd = 126;
p->action = -1;
strcpy(p->cmdName, "lag");
/* 470: = */
p = &cmdList[470];
p->index = 470;
p->parent = &cmdList[469];
p->left = &cmdList[471];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 471: digit */
p = &cmdList[471];
p->index = 471;
p->parent = &cmdList[470];
p->left = NULL;
p->sib = &cmdList[472];
p->rNde = &cmdList[53];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_INIT_LAG1;
strcpy(p->cmdName, "<number>");
/* 472: estimate */
p = &cmdList[472];
p->index = 472;
p->parent = &cmdList[470];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 37;
p->action = CMD_INIT_LAG2;
strcpy(p->cmdName, "estimate");
/* 473: lagpr */
p = &cmdList[473];
p->index = 473;
p->parent = &cmdList[201];
p->left = &cmdList[474];
p->sib = &cmdList[536];
p->rNde = NULL;
p->cmd = 127;
p->action = -1;
strcpy(p->cmdName, "lagpr");
/* 474: = */
p = &cmdList[474];
p->index = 474;
p->parent = &cmdList[473];
p->left = &cmdList[475];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 475: fixed */
p = &cmdList[475];
p->index = 475;
p->parent = &cmdList[474];
p->left = NULL;
p->sib = &cmdList[476];
p->rNde = &cmdList[201];
p->cmd = 66;
p->action = CMD_SET_LAG_PR1;
strcpy(p->cmdName, "fixed");
/* 476: uni */
p = &cmdList[476];
p->index = 476;
p->parent = &cmdList[474];
p->left = &cmdList[477];
p->sib = &cmdList[482];
p->rNde = NULL;
p->cmd = 68;
p->action = -1;
strcpy(p->cmdName, "uni");
/* 477: ( */
p = &cmdList[477];
p->index = 477;
p->parent = &cmdList[476];
p->left = &cmdList[478];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 478: digit */
p = &cmdList[478];
p->index = 478;
p->parent = &cmdList[477];
p->left = &cmdList[479];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_LAG_PR2;
strcpy(p->cmdName, "<number>");
/* 479: , */
p = &cmdList[479];
p->index = 479;
p->parent = &cmdList[478];
p->left = &cmdList[480];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COMMA;
p->action = -1;
strcpy(p->cmdName, ",");
/* 480: digit */
p = &cmdList[480];
p->index = 480;
p->parent = &cmdList[479];
p->left = &cmdList[481];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_LAG_PR3;
strcpy(p->cmdName, "digit");
/* 481: ) */
p = &cmdList[481];
p->index = 481;
p->parent = &cmdList[480];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 482: exp */
p = &cmdList[482];
p->index = 482;
p->parent = &cmdList[474];
p->left = &cmdList[483];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 67;
p->action = -1;
strcpy(p->cmdName, "exp");
/* 483: ( */
p = &cmdList[483];
p->index = 483;
p->parent = &cmdList[482];
p->left = &cmdList[484];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 484: digit */
p = &cmdList[484];
p->index = 484;
p->parent = &cmdList[483];
p->left = &cmdList[485];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_LAG_PR4;
strcpy(p->cmdName, "<number>");
/* 485: ) */
p = &cmdList[485];
p->index = 485;
p->parent = &cmdList[484];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 486: invariant */
p = &cmdList[486];
p->index = 486;
p->parent = &cmdList[58];
p->left = NULL;
p->sib = &cmdList[487];
p->rNde = &cmdList[53];
p->cmd = 128;
p->action = CMD_SET_RATES;
strcpy(p->cmdName, "invariant");
/* 487: invgamma */
p = &cmdList[487];
p->index = 487;
p->parent = &cmdList[58];
p->left = NULL;
p->sib = &cmdList[488];
p->rNde = &cmdList[53];
p->cmd = 129;
p->action = CMD_SET_RATES;
strcpy(p->cmdName, "invgamma");
/* 488: ssgamma */
p = &cmdList[488];
p->index = 488;
p->parent = &cmdList[58];
p->left = NULL;
p->sib = &cmdList[489];
p->rNde = &cmdList[53];
p->cmd = 130;
p->action = CMD_SET_RATES;
strcpy(p->cmdName, "ssgamma");
/* 489: ssadgamma */
p = &cmdList[489];
p->index = 489;
p->parent = &cmdList[58];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 131;
p->action = CMD_SET_RATES;
strcpy(p->cmdName, "ssadgamma");
/* 490: inferrates */
p = &cmdList[490];
p->index = 490;
p->parent = &cmdList[53];
p->left = &cmdList[491];
p->sib = &cmdList[62];
p->rNde = NULL;
p->cmd = 132;
p->action = -1;
strcpy(p->cmdName, "inferrates");
/* 491: = */
p = &cmdList[491];
p->index = 491;
p->parent = &cmdList[490];
p->left = &cmdList[492];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 492: yes */
p = &cmdList[492];
p->index = 492;
p->parent = &cmdList[491];
p->left = NULL;
p->sib = &cmdList[493];
p->rNde = &cmdList[53];
p->cmd = 17;
p->action = CMD_SET_INFERRATES1;
strcpy(p->cmdName, "yes");
/* 493: no */
p = &cmdList[493];
p->index = 493;
p->parent = &cmdList[491];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 18;
p->action = CMD_SET_INFERRATES2;
strcpy(p->cmdName, "no");
/* 494: = */
p = &cmdList[494];
p->index = 494;
p->parent = &cmdList[62];
p->left = &cmdList[495];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 495: yes */
p = &cmdList[495];
p->index = 495;
p->parent = &cmdList[494];
p->left = NULL;
p->sib = &cmdList[496];
p->rNde = &cmdList[53];
p->cmd = 17;
p->action = CMD_SET_COVARION1;
strcpy(p->cmdName, "yes");
/* 496: no */
p = &cmdList[496];
p->index = 496;
p->parent = &cmdList[494];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 18;
p->action = CMD_SET_COVARION2;
strcpy(p->cmdName, "no");
/* 497: covny98 */
p = &cmdList[497];
p->index = 497;
p->parent = &cmdList[430];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 133;
p->action = CMD_SET_OMEGAVAR5;
strcpy(p->cmdName, "covny98");
/* 498: restriction */
p = &cmdList[498];
p->index = 498;
p->parent = &cmdList[16];
p->left = NULL;
p->sib = &cmdList[527];
p->rNde = &cmdList[14];
p->cmd = 134;
p->action = CMD_INIT_DATATYPE;
strcpy(p->cmdName, "restriction");
/* 499: props */
p = &cmdList[499];
p->index = 499;
p->parent = &cmdList[41];
p->left = &cmdList[500];
p->sib = &cmdList[543];
p->rNde = NULL;
p->cmd = 151;
p->action = -1;
strcpy(p->cmdName, "props");
/* 500: qmatwin */
p = &cmdList[500];
p->index = 500;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[501];
p->rNde = NULL;
p->cmd = 135;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "qmatwin");
/* 501: pialpha */
p = &cmdList[501];
p->index = 501;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[502];
p->rNde = NULL;
p->cmd = 136;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "pialpha");
/* 502: alphawin */
p = &cmdList[502];
p->index = 502;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[503];
p->rNde = NULL;
p->cmd = 150;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "alphawin");
/* 503: ratewin */
p = &cmdList[503];
p->index = 503;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[504];
p->rNde = NULL;
p->cmd = 137;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "ratewin");
/* 504: tuning */
p = &cmdList[504];
p->index = 504;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[505];
p->rNde = NULL;
p->cmd = 138;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "tuning");
/* 505: clocktune */
p = &cmdList[505];
p->index = 505;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[506];
p->rNde = NULL;
p->cmd = 139;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "clocktune");
/* 506: timetune */
p = &cmdList[506];
p->index = 506;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[507];
p->rNde = NULL;
p->cmd = 140;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "timetune");
/* 507: mtune */
p = &cmdList[507];
p->index = 507;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[508];
p->rNde = NULL;
p->cmd = 141;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "mtune");
/* 508: extendp */
p = &cmdList[508];
p->index = 508;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[509];
p->rNde = NULL;
p->cmd = 142;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "extendp");
/* 509: wormtune */
p = &cmdList[509];
p->index = 509;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[510];
p->rNde = NULL;
p->cmd = 143;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "wormtune");
/* 510: bdwin */
p = &cmdList[510];
p->index = 510;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[511];
p->rNde = NULL;
p->cmd = 144;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "bdwin");
/* 511: omegawin */
p = &cmdList[511];
p->index = 511;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[512];
p->rNde = NULL;
p->cmd = 145;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "omegawin");
/* 512: omegaalpha */
p = &cmdList[512];
p->index = 512;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[513];
p->rNde = NULL;
p->cmd = 146;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "omegaalpha");
/* 513: rhowin */
p = &cmdList[513];
p->index = 513;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[514];
p->rNde = NULL;
p->cmd = 147;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "rhowin");
/* 514: invslide */
p = &cmdList[514];
p->index = 514;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[515];
p->rNde = NULL;
p->cmd = 148;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "invslide");
/* 515: switchwin */
p = &cmdList[515];
p->index = 515;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[516];
p->rNde = NULL;
p->cmd = 149;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "switchwin");
/* 516: ; */
p = &cmdList[516];
p->index = 516;
p->parent = &cmdList[499];
p->left = NULL;
p->sib = &cmdList[519];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = -1;
strcpy(p->cmdName, ";");
/* 517: = */
p = &cmdList[517];
p->index = 517;
p->parent = &cmdList[500];
p->left = &cmdList[518];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 518: digit */
p = &cmdList[518];
p->index = 518;
p->parent = &cmdList[517];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[499];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_PROPS2;
strcpy(p->cmdName, "<number>");
/* 519: reconlim */
p = &cmdList[519];
p->index = 519;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[524];
p->rNde = NULL;
p->cmd = 152;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "reconlim");
/* 520: covtype */
p = &cmdList[520];
p->index = 520;
p->parent = &cmdList[53];
p->left = &cmdList[521];
p->sib = &cmdList[529];
p->rNde = NULL;
p->cmd = 153;
p->action = -1;
strcpy(p->cmdName, "covtype");
/* 521: = */
p = &cmdList[521];
p->index = 521;
p->parent = &cmdList[520];
p->left = &cmdList[522];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 522: ts98 */
p = &cmdList[522];
p->index = 522;
p->parent = &cmdList[521];
p->left = NULL;
p->sib = &cmdList[523];
p->rNde = &cmdList[53];
p->cmd = 154;
p->action = CMD_SET_COVTYPE;
strcpy(p->cmdName, "ts98");
/* 523: gcswitch */
p = &cmdList[523];
p->index = 523;
p->parent = &cmdList[521];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 155;
p->action = CMD_SET_COVTYPE;
strcpy(p->cmdName, "gcswitch");
/* 524: tbrextendp */
p = &cmdList[524];
p->index = 524;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[525];
p->rNde = NULL;
p->cmd = 156;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "tbrextendp");
/* 525: tbrtune */
p = &cmdList[525];
p->index = 525;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = &cmdList[526];
p->rNde = NULL;
p->cmd = 157;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "tbrtune");
/* 526: bltune */
p = &cmdList[526];
p->index = 526;
p->parent = &cmdList[499];
p->left = &cmdList[517];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 158;
p->action = CMD_SET_PROPS1;
strcpy(p->cmdName, "bltune");
/* 527: standard */
p = &cmdList[527];
p->index = 527;
p->parent = &cmdList[16];
p->left = NULL;
p->sib = &cmdList[528];
p->rNde = &cmdList[14];
p->cmd = 159;
p->action = CMD_INIT_DATATYPE;
strcpy(p->cmdName, "standard");
/* 528: mixed */
p = &cmdList[528];
p->index = 528;
p->parent = &cmdList[16];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[14];
p->cmd = 160;
p->action = CMD_INIT_DATATYPE;
strcpy(p->cmdName, "mixed");
/* 529: coding */
p = &cmdList[529];
p->index = 529;
p->parent = &cmdList[53];
p->left = &cmdList[530];
p->sib = &cmdList[565];
p->rNde = NULL;
p->cmd = 161;
p->action = -1;
strcpy(p->cmdName, "coding");
/* 530: = */
p = &cmdList[530];
p->index = 530;
p->parent = &cmdList[529];
p->left = &cmdList[531];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 531: all */
p = &cmdList[531];
p->index = 531;
p->parent = &cmdList[530];
p->left = NULL;
p->sib = &cmdList[532];
p->rNde = &cmdList[53];
p->cmd = 52;
p->action = CMD_SET_CODING;
strcpy(p->cmdName, "all");
/* 532: variable */
p = &cmdList[532];
p->index = 532;
p->parent = &cmdList[530];
p->left = NULL;
p->sib = &cmdList[533];
p->rNde = &cmdList[53];
p->cmd = 162;
p->action = CMD_SET_CODING;
strcpy(p->cmdName, "variable");
/* 533: informative */
p = &cmdList[533];
p->index = 533;
p->parent = &cmdList[530];
p->left = NULL;
p->sib = &cmdList[534];
p->rNde = &cmdList[53];
p->cmd = 163;
p->action = CMD_SET_CODING;
strcpy(p->cmdName, "informative");
/* 534: noabsence */
p = &cmdList[534];
p->index = 534;
p->parent = &cmdList[530];
p->left = NULL;
p->sib = &cmdList[535];
p->rNde = &cmdList[53];
p->cmd = 164;
p->action = CMD_SET_CODING;
strcpy(p->cmdName, "noabsence");
/* 535: nopresence */
p = &cmdList[535];
p->index = 535;
p->parent = &cmdList[530];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 165;
p->action = CMD_SET_CODING;
strcpy(p->cmdName, "nopresence");
/* 536: statefreqpr */
p = &cmdList[536];
p->index = 536;
p->parent = &cmdList[201];
p->left = &cmdList[537];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 166;
p->action = -1;
strcpy(p->cmdName, "statefreqpr");
/* 537: = */
p = &cmdList[537];
p->index = 537;
p->parent = &cmdList[536];
p->left = &cmdList[538];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 538: fixed */
p = &cmdList[538];
p->index = 538;
p->parent = &cmdList[537];
p->left = NULL;
p->sib = &cmdList[539];
p->rNde = &cmdList[201];
p->cmd = 66;
p->action = CMD_SET_STATE_PR1;
strcpy(p->cmdName, "fixed");
/* 539: dir */
p = &cmdList[539];
p->index = 539;
p->parent = &cmdList[537];
p->left = &cmdList[540];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 70;
p->action = -1;
strcpy(p->cmdName, "dir");
/* 540: ( */
p = &cmdList[540];
p->index = 540;
p->parent = &cmdList[539];
p->left = &cmdList[541];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + LEFTPAR;
p->action = -1;
strcpy(p->cmdName, "(");
/* 541: digit */
p = &cmdList[541];
p->index = 541;
p->parent = &cmdList[540];
p->left = &cmdList[542];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_STATE_PR2;
strcpy(p->cmdName, "<number>");
/* 542: ) */
p = &cmdList[542];
p->index = 542;
p->parent = &cmdList[541];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[201];
p->cmd = NUMCOMMANDS + RIGHTPAR;
p->action = -1;
strcpy(p->cmdName, ")");
/* 543: setmoveprops */
p = &cmdList[543];
p->index = 543;
p->parent = &cmdList[41];
p->left = &cmdList[544];
p->sib = &cmdList[569];
p->rNde = NULL;
p->cmd = 167;
p->action = -1;
strcpy(p->cmdName, "setmoveprops");
/* 544: ; */
p = &cmdList[544];
p->index = 544;
p->parent = &cmdList[543];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SET_MOVE_PROPS;
strcpy(p->cmdName, ";");
/* 545: burnin */
p = &cmdList[545];
p->index = 545;
p->parent = &cmdList[178];
p->left = &cmdList[546];
p->sib = &cmdList[548];
p->rNde = NULL;
p->cmd = 91;
p->action = -1;
strcpy(p->cmdName, "burnin");
/* 546: = */
p = &cmdList[546];
p->index = 546;
p->parent = &cmdList[545];
p->left = &cmdList[547];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 547: digit */
p = &cmdList[547];
p->index = 547;
p->parent = &cmdList[546];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_MCMC_BURN;
strcpy(p->cmdName, "<number>");
/* 548: cyclefreq */
p = &cmdList[548];
p->index = 548;
p->parent = &cmdList[178];
p->left = &cmdList[549];
p->sib = &cmdList[551];
p->rNde = NULL;
p->cmd = 168;
p->action = -1;
strcpy(p->cmdName, "cyclefreq");
/* 549: = */
p = &cmdList[549];
p->index = 549;
p->parent = &cmdList[548];
p->left = &cmdList[550];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 550: digit */
p = &cmdList[550];
p->index = 550;
p->parent = &cmdList[549];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_CYCLEFREQ;
strcpy(p->cmdName, "<number>");
/* 551: calcpseudobf */
p = &cmdList[551];
p->index = 551;
p->parent = &cmdList[178];
p->left = &cmdList[552];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 169;
p->action = -1;
strcpy(p->cmdName, "calcpseudobf");
/* 552: = */
p = &cmdList[552];
p->index = 552;
p->parent = &cmdList[551];
p->left = &cmdList[553];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 553: yes */
p = &cmdList[553];
p->index = 553;
p->parent = &cmdList[552];
p->left = NULL;
p->sib = &cmdList[554];
p->rNde = &cmdList[178];
p->cmd = 17;
p->action = CMD_SET_CALCPSEUDOBF;
strcpy(p->cmdName, "yes");
/* 554: no */
p = &cmdList[554];
p->index = 554;
p->parent = &cmdList[552];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[178];
p->cmd = 18;
p->action = CMD_SET_CALCPSEUDOBF;
strcpy(p->cmdName, "no");
/* 555: burnin */
p = &cmdList[555];
p->index = 555;
p->parent = &cmdList[377];
p->left = &cmdList[556];
p->sib = &cmdList[558];
p->rNde = NULL;
p->cmd = 91;
p->action = -1;
strcpy(p->cmdName, "burnin");
/* 556: = */
p = &cmdList[556];
p->index = 556;
p->parent = &cmdList[555];
p->left = &cmdList[557];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 557: digit */
p = &cmdList[557];
p->index = 557;
p->parent = &cmdList[556];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_MCMC_BURN;
strcpy(p->cmdName, "<number>");
/* 558: cyclefreq */
p = &cmdList[558];
p->index = 558;
p->parent = &cmdList[377];
p->left = &cmdList[559];
p->sib = &cmdList[561];
p->rNde = NULL;
p->cmd = 168;
p->action = -1;
strcpy(p->cmdName, "cyclefreq");
/* 559: = */
p = &cmdList[559];
p->index = 559;
p->parent = &cmdList[558];
p->left = &cmdList[560];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 560: digit */
p = &cmdList[560];
p->index = 560;
p->parent = &cmdList[559];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_CYCLEFREQ;
strcpy(p->cmdName, "<number>");
/* 561: calcpseudobf */
p = &cmdList[561];
p->index = 561;
p->parent = &cmdList[377];
p->left = &cmdList[562];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 169;
p->action = -1;
strcpy(p->cmdName, "calcpseudobf");
/* 562: = */
p = &cmdList[562];
p->index = 562;
p->parent = &cmdList[561];
p->left = &cmdList[563];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 563: yes */
p = &cmdList[563];
p->index = 563;
p->parent = &cmdList[562];
p->left = NULL;
p->sib = &cmdList[564];
p->rNde = &cmdList[377];
p->cmd = 17;
p->action = CMD_SET_CALCPSEUDOBF;
strcpy(p->cmdName, "yes");
/* 564: no */
p = &cmdList[564];
p->index = 564;
p->parent = &cmdList[562];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[377];
p->cmd = 18;
p->action = CMD_SET_CALCPSEUDOBF;
strcpy(p->cmdName, "no");
/* 565: parsmodel */
p = &cmdList[565];
p->index = 565;
p->parent = &cmdList[53];
p->left = &cmdList[566];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 170;
p->action = -1;
strcpy(p->cmdName, "parsmodel");
/* 566: = */
p = &cmdList[566];
p->index = 566;
p->parent = &cmdList[565];
p->left = &cmdList[567];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 567: yes */
p = &cmdList[567];
p->index = 567;
p->parent = &cmdList[566];
p->left = NULL;
p->sib = &cmdList[568];
p->rNde = &cmdList[53];
p->cmd = 17;
p->action = CMD_SET_PARS_CRIT;
strcpy(p->cmdName, "yes");
/* 568: no */
p = &cmdList[568];
p->index = 568;
p->parent = &cmdList[566];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[53];
p->cmd = 18;
p->action = CMD_SET_PARS_CRIT;
strcpy(p->cmdName, "no");
/* 569: typeset */
p = &cmdList[569];
p->index = 569;
p->parent = &cmdList[41];
p->left = &cmdList[570];
p->sib = &cmdList[582];
p->rNde = NULL;
p->cmd = 171;
p->action = CMD_SET_TYPESET1;
strcpy(p->cmdName, "typeset");
/* 570: name */
p = &cmdList[570];
p->index = 570;
p->parent = &cmdList[569];
p->left = &cmdList[572];
p->sib = &cmdList[571];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_SET_TYPESET2;
strcpy(p->cmdName, "<typeset name>");
/* 571: number */
p = &cmdList[571];
p->index = 571;
p->parent = &cmdList[569];
p->left = &cmdList[572];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_TYPESET3;
strcpy(p->cmdName, "<typeset digit");
/* 572: = */
p = &cmdList[572];
p->index = 572;
p->parent = &cmdList[570];
p->left = &cmdList[573];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 573: ord */
p = &cmdList[573];
p->index = 573;
p->parent = &cmdList[572];
p->left = &cmdList[575];
p->sib = &cmdList[574];
p->rNde = NULL;
p->cmd = 173;
p->action = CMD_SET_TYPESET4;
strcpy(p->cmdName, "ord");
/* 574: unord */
p = &cmdList[574];
p->index = 574;
p->parent = &cmdList[572];
p->left = &cmdList[575];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 174;
p->action = CMD_SET_TYPESET4;
strcpy(p->cmdName, "unord");
/* 575: : */
p = &cmdList[575];
p->index = 575;
p->parent = &cmdList[573];
p->left = &cmdList[576];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COLON;
p->action = CMD_SET_TYPESET5;
strcpy(p->cmdName, ":");
/* 576: digit */
p = &cmdList[576];
p->index = 576;
p->parent = &cmdList[575];
p->left = NULL;
p->sib = &cmdList[577];
p->rNde = &cmdList[575];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_TYPESET6;
strcpy(p->cmdName, "digit");
/* 577: - */
p = &cmdList[577];
p->index = 577;
p->parent = &cmdList[575];
p->left = NULL;
p->sib = &cmdList[578];
p->rNde = &cmdList[575];
p->cmd = NUMCOMMANDS + DASH;
p->action = CMD_SET_TYPESET7;
strcpy(p->cmdName, "-");
/* 578: \ */
p = &cmdList[578];
p->index = 578;
p->parent = &cmdList[575];
p->left = NULL;
p->sib = &cmdList[579];
p->rNde = &cmdList[575];
p->cmd = NUMCOMMANDS + FORWARDSLASH;
p->action = CMD_SET_TYPESET8;
strcpy(p->cmdName, "\\");
/* 579: ; */
p = &cmdList[579];
p->index = 579;
p->parent = &cmdList[575];
p->left = NULL;
p->sib = &cmdList[580];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SET_TYPESET9;
strcpy(p->cmdName, ";");
/* 580: name */
p = &cmdList[580];
p->index = 580;
p->parent = &cmdList[575];
p->left = NULL;
p->sib = &cmdList[581];
p->rNde = &cmdList[575];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_SET_TYPESET10;
strcpy(p->cmdName, "<charset name>");
/* 581: , */
p = &cmdList[581];
p->index = 581;
p->parent = &cmdList[575];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[572];
p->cmd = NUMCOMMANDS + COMMA;
p->action = CMD_SET_TYPESET11;
strcpy(p->cmdName, ",");
/* 582: nstatesset */
p = &cmdList[582];
p->index = 582;
p->parent = &cmdList[41];
p->left = &cmdList[583];
p->sib = &cmdList[594];
p->rNde = NULL;
p->cmd = 172;
p->action = CMD_SET_STATESSET1;
strcpy(p->cmdName, "nstatesset");
/* 583: name */
p = &cmdList[583];
p->index = 583;
p->parent = &cmdList[582];
p->left = &cmdList[585];
p->sib = &cmdList[584];
p->rNde = NULL;
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_SET_STATESSET2;
strcpy(p->cmdName, "<nstatesset name>");
/* 584: number */
p = &cmdList[584];
p->index = 584;
p->parent = &cmdList[582];
p->left = &cmdList[585];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_STATESSET3;
strcpy(p->cmdName, "<nstatesset number>");
/* 585: = */
p = &cmdList[585];
p->index = 585;
p->parent = &cmdList[583];
p->left = &cmdList[586];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 586: digit */
p = &cmdList[586];
p->index = 586;
p->parent = &cmdList[585];
p->left = &cmdList[587];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_STATESSET4;
strcpy(p->cmdName, "<number>");
/* 587: : */
p = &cmdList[587];
p->index = 587;
p->parent = &cmdList[586];
p->left = &cmdList[588];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + COLON;
p->action = CMD_SET_STATESSET5;
strcpy(p->cmdName, ":");
/* 588: digit */
p = &cmdList[588];
p->index = 588;
p->parent = &cmdList[587];
p->left = NULL;
p->sib = &cmdList[589];
p->rNde = &cmdList[587];
p->cmd = NUMCOMMANDS + NUMBER;
p->action = CMD_SET_STATESSET6;
strcpy(p->cmdName, "<number>");
/* 589: - */
p = &cmdList[589];
p->index = 589;
p->parent = &cmdList[587];
p->left = NULL;
p->sib = &cmdList[590];
p->rNde = &cmdList[587];
p->cmd = NUMCOMMANDS + DASH;
p->action = CMD_SET_STATESSET7;
strcpy(p->cmdName, "-");
/* 590: \ */
p = &cmdList[590];
p->index = 590;
p->parent = &cmdList[587];
p->left = NULL;
p->sib = &cmdList[591];
p->rNde = &cmdList[587];
p->cmd = NUMCOMMANDS + FORWARDSLASH;
p->action = CMD_SET_STATESSET8;
strcpy(p->cmdName, "\\");
/* 591: ; */
p = &cmdList[591];
p->index = 591;
p->parent = &cmdList[587];
p->left = NULL;
p->sib = &cmdList[592];
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = CMD_SET_STATESSET9;
strcpy(p->cmdName, ";");
/* 592: name */
p = &cmdList[592];
p->index = 592;
p->parent = &cmdList[587];
p->left = NULL;
p->sib = &cmdList[593];
p->rNde = &cmdList[587];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_SET_STATESSET10;
strcpy(p->cmdName, "<charset name>");
/* 593: , */
p = &cmdList[593];
p->index = 593;
p->parent = &cmdList[587];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[585];
p->cmd = NUMCOMMANDS + COMMA;
p->action = CMD_SET_STATESSET11;
strcpy(p->cmdName, ",");
/* 594: assume */
p = &cmdList[594];
p->index = 594;
p->parent = &cmdList[41];
p->left = &cmdList[595];
p->sib = NULL;
p->rNde = NULL;
p->cmd = 175;
p->action = -1;
strcpy(p->cmdName, "assume");
/* 595: typeset */
p = &cmdList[595];
p->index = 595;
p->parent = &cmdList[594];
p->left = &cmdList[596];
p->sib = &cmdList[598];
p->rNde = NULL;
p->cmd = 171;
p->action = -1;
strcpy(p->cmdName, "typeset");
/* 596: = */
p = &cmdList[596];
p->index = 596;
p->parent = &cmdList[595];
p->left = &cmdList[597];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 597: name */
p = &cmdList[597];
p->index = 597;
p->parent = &cmdList[596];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[594];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_SET_ASSUME1;
strcpy(p->cmdName, "<typeset name>");
/* 598: nstatesset */
p = &cmdList[598];
p->index = 598;
p->parent = &cmdList[594];
p->left = &cmdList[599];
p->sib = &cmdList[601];
p->rNde = NULL;
p->cmd = 172;
p->action = -1;
strcpy(p->cmdName, "nstatesset");
/* 599: = */
p = &cmdList[599];
p->index = 599;
p->parent = &cmdList[598];
p->left = &cmdList[600];
p->sib = NULL;
p->rNde = NULL;
p->cmd = NUMCOMMANDS + EQUALSIGN;
p->action = -1;
strcpy(p->cmdName, "=");
/* 600: name */
p = &cmdList[600];
p->index = 600;
p->parent = &cmdList[599];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[594];
p->cmd = NUMCOMMANDS + ALPHA;
p->action = CMD_SET_ASSUME2;
strcpy(p->cmdName, "name");
/* 601: ; */
p = &cmdList[601];
p->index = 601;
p->parent = &cmdList[594];
p->left = NULL;
p->sib = NULL;
p->rNde = &cmdList[41];
p->cmd = NUMCOMMANDS + SEMICOLON;
p->action = -1;
strcpy(p->cmdName, ";");
/* 602: yyy */
p = &cmdList[602];
p->index = 602;
p->parent = NULL;
p->left = NULL;
p->sib = NULL;
p->rNde = NULL;
p->cmd = -1;
p->action = -1;
strcpy(p->cmdName, "yyy");
/* 603: yyy */
p = &cmdList[603];
p->index = 603;
p->parent = NULL;
p->left = NULL;
p->sib = NULL;
p->rNde = NULL;
p->cmd = -1;
p->action = -1;
strcpy(p->cmdName, "yyy");
/* 604: yyy */
p = &cmdList[604];
p->index = 604;
p->parent = NULL;
p->left = NULL;
p->sib = NULL;
p->rNde = NULL;
p->cmd = -1;
p->action = -1;
strcpy(p->cmdName, "yyy");
/* 605: yyy */
p = &cmdList[605];
p->index = 605;
p->parent = NULL;
p->left = NULL;
p->sib = NULL;
p->rNde = NULL;
p->cmd = -1;
p->action = -1;
strcpy(p->cmdName, "yyy");
# if 0
{
int i;
for (i=0; i<371; i++)
{
p = &cmdList[i];
printf ("%3d (%3d %3d %3d %3d) %3d %s | ",
Dex(p), Dex(p->parent), Dex(p->left), Dex(p->sib), Dex(p->rNde), p->cmd, p->cmdName);
if (p->parent != NULL)
printf ("%s -> ", p->parent->cmdName);
else
printf ("NULL -> ");
printf ("%s -> ", p->cmdName);
if (p->left != NULL)
printf ("%s ", p->left->cmdName);
else
printf ("NULL ");
printf ("\n");
}
}
# endif
}
void ShowNodes (TreeNode *p, int indent, int isThisTreeRooted)
{
if (p != NULL)
{
printf (" ");
if (p->left == NULL && p->right == NULL && p->anc != NULL)
{
printf("%*cN %d (l=%d r=%d a=%d) %lf (%s) ",
indent, ' ', Dex2(p), Dex2(p->left), Dex2(p->right), Dex2(p->anc), p->length, p->label);
}
else if (p->left != NULL && p->right == NULL && p->anc == NULL)
{
if (isThisTreeRooted == NO)
{
if (p->label[0] == '\0' || p->label[0] == '\n' || p->label[0] == ' ')
printf("%*cN %d (l=%d r=%d a=%d) (---) ",
indent, ' ', Dex2(p), Dex2(p->left), Dex2(p->right), Dex2(p->anc));
else
printf("%*cN %d (l=%d r=%d a=%d) (%s) ",
indent, ' ', Dex2(p), Dex2(p->left), Dex2(p->right), Dex2(p->anc), p->label);
}
else
{
printf("%*cN %d (l=%d r=%d a=%d) X.XXXXXX ",
indent, ' ', Dex2(p), Dex2(p->left), Dex2(p->right), Dex2(p->anc));
}
}
else
{
if (p->anc != NULL)
{
if (p->anc->anc == NULL && isThisTreeRooted == YES)
printf("%*cN %d (l=%d r=%d a=%d) X.XXXXXX ",
indent, ' ', Dex2(p), Dex2(p->left), Dex2(p->right), Dex2(p->anc));
else
printf("%*cN %d (l=%d r=%d a=%d) %lf ",
indent, ' ', Dex2(p), Dex2(p->left), Dex2(p->right), Dex2(p->anc), p->length);
}
}
if (enforceCalibrations == YES)
{
if (p->anc != NULL)
{
printf ("%1.3lf ", p->nodeTime);
if (p->isCalibrated == YES)
printf (" <== %s (%1.3lf %1.3lf)", p->calibrationName, p->calTime[0], p->calTime[1]);
}
}
if (enforceConstraints == YES)
{
if (p->isConstrained == YES)
printf (" <== %s ", p->constraintName);
}
printf ("\n");
ShowNodes (p->left, indent + 2, isThisTreeRooted);
ShowNodes (p->right, indent + 2, isThisTreeRooted);
}
}
#if defined (CONTREE)
int ShowConPhylogram (FILE *fp, int nNodes, PolyNode *root, int screenWidth)
{
int i, j, k, nLines, from, to, treeWidth;
char *printLine, *markLine;
double scale, f;
PolyNode *p, *q, **allDownPass;
// allocate space for printLine and markLine
printLine = (char *) calloc ((2*screenWidth+1),sizeof(char));
if (!printLine)
return ERROR;
markLine = printLine + screenWidth + 1;
// allocate allDownPass
allDownPass = (PolyNode **) malloc (nNodes * sizeof(PolyNode *));
if (!allDownPass)
return ERROR;
// get fresh downpass sequence
i = 0;
GetConDownPass(allDownPass, root, &i);
// calculate scale
scale = 0.0;
root->f = 0.0;
for (i=nNodes-2; i>=0; i--)
{
p = allDownPass[i];
p->f = p->anc->f + p->length;
if (p->left == NULL)
{
f = p->f / (screenWidth - strlen(p->label) - 2);
if (f > scale)
{
scale = f;
treeWidth = screenWidth - strlen(p->label) - 2;
}
}
}
// calculate x coordinates
for (i=0; i<nNodes; i++)
{
p = allDownPass[i];
p->x = (int) (0.5 + (p->f / scale));
}
// calculate y coordinates and lines to print
for (i=nLines=0; i<nNodes; i++)
{
p = allDownPass[i];
if (p->left != NULL)
{
// internal node
for (q=p->left->sib; q->sib!=NULL; q=q->sib)
;
p->y = (int) (0.5 + ((p->left->y + q->y) / 2.0));
}
else
{
// terminal node
p->y = nLines;
nLines += 2;
}
}
// print tree line by line
for (i=0; i<nLines; i++)
{
// empty printLine
for (j=0; j<screenWidth; j++)
{
printLine[j] = ' ';
}
printLine[j]='\0';
for (j=0; j<nNodes; j++)
{
p = allDownPass[j];
if (p->y != i)
continue;
// this branch should be printed
// add branch
if (p->anc == NULL)
{
// this is the root of the whole tree
printLine[p->x] = '+';
}
else
{
// this is an ordinary branch
to = p->x;
from = p->anc->x;
for (k=from+1; k<=to; k++)
printLine[k] = '-';
if (p == p->anc->left)
{
if (markLine[from] == 0)
printLine[from] = '/';
else
printLine[from] = '|';
markLine[from] ++;
}
else if (p->sib == NULL)
{
if (markLine[from] == 1)
printLine[from] = '\\';
else
printLine[from] = '|';
markLine[from] --;
}
if (p->left!=NULL)
{
if (from != to)
printLine[to] = '+';
else
printLine[to] = '|';
}
else
{
// add label if the branch is terminal
sprintf(printLine+to+2,"%s",p->label);
}
}
}
// check for cross branches
for (j=0; j<screenWidth; j++)
{
if (markLine[j] >= 1 && printLine[j] == ' ')
printLine[j] = '|';
}
fprintf(fp, "%s\n",printLine);
}
// print scale
for (i=0; i<treeWidth; i++)
if (i % 10 == 0)
printLine[i] = '+';
else
printLine[i] = '-';
printLine[i++] = '>';
printLine[i] = '\0';
fprintf(fp, "%s\n",printLine);
printLine[0] = '0';
printLine[1] = '.';
printLine[2] = '0';
f = scale * 10.0;
for (i=3; i<treeWidth - 5; i++)
{
if ( (i + 3) % 10 == 0)
{
j = (int) log10(f);
j = j > 1 ? j : 1;
sprintf (printLine + i, "%7.*f", 6 - j, f);
f += (scale * 10.0);
i += 6;
}
else
printLine[i] = ' ';
}
printLine[i] = '\0';
fprintf(fp, "%s\n",printLine);
free (allDownPass);
free (printLine);
return NO_ERROR;
}
int ShowConTree (FILE *fp, int nNodes, PolyNode *root, int screenWidth)
{
int i, j, k, treeWidth, minBranchLength, maxWidth, isTreeDivided,
printWidth, nLines, nodesToBePrinted, from, to;
unsigned int maxLabelLength;
char *printLine, *markLine, temp[20];
PolyNode *p, *q, **allDownPass;
minBranchLength = 5;
isTreeDivided = NO;
// allocate space for printLine and markLine
printLine = (char *) calloc ((2*screenWidth+1),sizeof(char));
if (!printLine)
return ERROR;
markLine = printLine + screenWidth + 1;
// allocate allDownPass
allDownPass = (PolyNode **) malloc (nNodes * sizeof(PolyNode *));
if (!allDownPass)
return ERROR;
// get fresh downpass sequence and internal node indices
i = 0;
GetConDownPass(allDownPass, root, &i);
for (i=k=0; i<nNodes; i++)
if (allDownPass[i]->left == NULL)
k++;
for (i=0; i<nNodes; i++)
{
p = allDownPass[i];
if (p->left != NULL)
p->index = k++;
}
// calculate max length of labels
// initially set to hold largest node index number plus parentheses
maxLabelLength = (unsigned int) (3.0 + log10((double)nNodes));
for (i=0; i<nNodes; i++)
{
p = allDownPass[i];
if (p->left == NULL && strlen(p->label)>maxLabelLength)
maxLabelLength = strlen(p->label);
}
// calculate remaining screen width for tree
// and maxWidth in terms of branches
treeWidth = screenWidth - maxLabelLength - 1;
maxWidth = treeWidth / minBranchLength;
// unmark whole tree
for (i=0; i<nNodes; i++)
allDownPass[i]->mark = 0;
nodesToBePrinted = nNodes;
while (nodesToBePrinted > 0)
{
// count depth of nodes in unprinted tree
for (i=0; i<nNodes; i++)
{
p = allDownPass[i];
if (p->mark == 0)
{
p->x = 0;
if (p->left != NULL && p->left->mark == 0)
{
for (q = p->left; q!=NULL; q=q->sib)
{
if (q->x > p->x)
p->x = q->x;
}
p->x++;
// break when root of print subtree has been found
if (p->x >= maxWidth)
break;
}
}
}
// if internal node then find largest nonprinted subtree among descendant nodes
if (p->anc != NULL)
{
for (q=p->left; q!=NULL; q=q->sib)
{
if (q->x == p->x - 1 && q->mark == 0)
p = q;
}
fprintf (fp, "Subclade rooted at node %d:\n\n",p->index);
isTreeDivided = YES;
}
else if (isTreeDivided == YES)
fprintf (fp, "Root part of tree:\n\n");
// mark subtree for printing and
// translate x coordinates from depth to position
if (p->anc == NULL)
printWidth = p->x;
else
printWidth = p->x + 1;
p->mark = 1;
p->x = (int) (treeWidth - 0.5 - ((treeWidth - 1) * (p->x / (double) printWidth)));
for (i--; i>=0; i--)
{
p = allDownPass[i];
if (p->mark == 0 && p->anc->mark == 1)
{
p->mark = 1;
p->x = (int) (treeWidth - 0.5 - ((treeWidth - 1) * (p->x / (double) printWidth)));
}
}
// calculate y coordinates of nodes to be printed and lines to print
for (i=nLines=0; i<nNodes; i++)
{
p = allDownPass[i];
if (p->mark == 1)
{
if (p->left != NULL && p->left->mark == 1)
{
// internal node
for (q=p->left->sib; q->sib!=NULL; q=q->sib)
;
p->y = (int) (0.5 + ((p->left->y + q->y) / 2.0));
}
else
{
// terminal node
p->y = nLines;
nLines += 2;
}
}
}
// print subtree line by line
for (i=0; i<nLines; i++)
{
// empty printLine
for (j=0; j<screenWidth; j++)
{
printLine[j] = ' ';
}
printLine[j]='\0';
for (j=0; j<nNodes; j++)
{
p = allDownPass[j];
if (p->mark != 1 || p->y != i)
continue;
// this branch should be printed
// add label if the branch is terminal in tree to be printed
if (p->left == NULL)
sprintf(printLine+treeWidth+1,"%s",p->label);
else if (p->left->mark == 2)
sprintf(printLine+treeWidth+1,"(%d)",p->index);
// add branch
if (p->anc == NULL)
{
// this is the root of the whole tree
printLine[p->x] = '+';
nodesToBePrinted--;
}
else if (p->anc->mark == 0)
{
// this is a root of a subtree
// this branch will have to be printed again so do
// not decrease nodesToBePrinted
to = p->x;
from = 0;
for (k=from; k<to; k++)
printLine[k] = '-';
printLine[to] = '+';
sprintf(temp,"%d\0", (int) (p->support + 0.5));
from = (int)(from + 1.5 + ((to - from - 1 - strlen(temp)) / 2.0));
for (k=0; temp[k]!='\0'; k++)
printLine[from++] = temp[k];
}
else
{
// this is an ordinary branch
to = p->x;
from = p->anc->x;
for (k=from+1; k<=to; k++)
printLine[k] = '-';
if (p == p->anc->left)
{
printLine[from] = '/';
markLine[from] = 1;
}
else if (p->sib == NULL)
{
printLine[from] = '\\';
markLine[from] = 0;
}
if (p->left!=NULL && p->left->mark!=2)
{
printLine[to] = '+';
sprintf(temp,"%d\0", (int) (p->support + 0.5));
from = (int)(from + 1.5 + ((to - from - 1 - strlen(temp)) / 2.0));
for (k=0; temp[k]!='\0'; k++)
printLine[from++] = temp[k];
}
nodesToBePrinted--;
}
}
// check for cross branches
for (j=0; j<treeWidth; j++)
{
if (markLine[j] == 1 && printLine[j] == ' ')
printLine[j] = '|';
}
fprintf(fp, "%s\n",printLine);
}
// mark printed branches
for (i=0; i<nNodes; i++)
{
p = allDownPass[i];
if (p->mark == 1)
{
if (p->anc == NULL)
p->mark = 2;
else if (p->anc->mark == 0)
p->mark = 0; // this branch will have to be printed again
else
p->mark = 2;
}
}
} // next subtree
free (allDownPass);
free (printLine);
return NO_ERROR;
}
#endif
#define EDDIE_NODES
int ShowTree (TreeNode *r, int isThisTreeRooted)
{
int i, j, k, nNodes, x, nLines, nLevels, levelDepth, from, to;
char treeLine[SCREENWIDTH2], labelLine[100];
TreeNode **downPass, *p;
/* get down pass sequence */
if (isThisTreeRooted == YES)
nNodes = 2 * nTaxa;
else
nNodes = 2 * nTaxa - 2;
downPass = (TreeNode **)malloc((size_t) (2 * nTaxa * sizeof(TreeNode *)));
if (!downPass)
{
printf (" ERROR: Could not allocate downPass\n");
return (ERROR);
}
i = 0;
GetUserDownPass (r, downPass, &i);
/* get coordinates */
x = 0;
nLines = 0;
for (i=0; i<nNodes; i++)
{
p = downPass[i];
if (p->left == NULL && p->right == NULL)
{
p->x = x;
x += 2;
p->y = 0;
nLines += 2;
}
else if (p->left != NULL && p->right != NULL && p->anc != NULL)
{
p->x = p->left->x + (p->right->x - p->left->x) / 2;
if (p->left->y > p->right->y)
p->y = p->left->y + 1;
else
p->y = p->right->y + 1;
}
else
{
p->x = x;
x += 2;
p->y = 0;
}
}
/* print tree out, line-by-line */
levelDepth = SCREENWIDTH / r->left->y;
nLevels = r->left->y;
for (j=0; j<=nLines-2; j++)
{
if (j % 2 == 0)
{
for (i=0; i<nNodes; i++)
{
p = downPass[i];
if (p->left == NULL && p->x == j)
{
strcpy (labelLine, p->label);
}
}
}
for (i=0; i<SCREENWIDTH-1; i++)
treeLine[i] = ' ';
treeLine[SCREENWIDTH-1] = '\0';
for (i=0; i<nNodes; i++)
{
p = downPass[i];
if (p->anc != NULL)
{
if (p->anc->anc != NULL)
{
if (p->x == j)
{
from = (nLevels - p->anc->y) * levelDepth;
to = (nLevels - p->y) * levelDepth;
if (p->y == 0)
to = SCREENWIDTH-1;
if (to >= SCREENWIDTH)
to = SCREENWIDTH-1;
for (k=from; k<to; k++)
treeLine[k] = '-';
if (p->anc->left == p)
treeLine[from] = '/';
else
treeLine[from] = '\\';
if (p->left != NULL)
{
# if defined (EDDIE_NODES)
treeLine[to] = '|';
# else
treeLine[to] = '+';
# endif
}
if (p->anc->anc == r && p->anc->right == p)
{
if (isThisTreeRooted == NO)
# if defined (EDDIE_NODES)
treeLine[to] = '|';
# else
treeLine[to] = '+';
# endif
else
treeLine[from] = '\\';
}
}
else
{
if (p->left != NULL && p->right != NULL)
{
if (j < p->x && j > p->left->x)
{
from = (nLevels - p->y) * levelDepth;
treeLine[from] = '|';
}
else if (j > p->x && j < p->right->x && p->left != NULL)
{
from = (nLevels - p->y) * levelDepth;
treeLine[from] = '|';
}
}
}
}
else
{
if (p->x == j)
{
treeLine[0] = '|'; /* temp */
}
else if (j < p->x && j > p->left->x)
{
treeLine[0] = '|';
}
else if (j > p->x && j < p->right->x)
{
treeLine[0] = '|';
}
if (isThisTreeRooted == NO)
{
if (j > p->x && j <= nLines-2)
treeLine[0] = '|';
if (j == p->right->x)
# if defined (EDDIE_NODES)
treeLine[0] = '|';
# else
treeLine[0] = '+';
# endif
}
else
{
if (j == p->x)
# if defined (EDDIE_NODES)
treeLine[0] = '|';
# else
treeLine[0] = '+';
# endif
}
}
}
}
treeLine[SCREENWIDTH-1] = '\0';
if (j % 2 == 0)
printf (" %s %s\n", treeLine, labelLine);
else
printf (" %s \n", treeLine);
}
if (isThisTreeRooted == NO)
{
for (i=0; i<SCREENWIDTH; i++)
treeLine[i] = ' ';
treeLine[SCREENWIDTH-1] = '\0';
printf (" |\n");
for (k=0; k<SCREENWIDTH; k++)
treeLine[k] = '-';
treeLine[SCREENWIDTH-1] = '\0';
treeLine[0] = '\\';
strcpy (labelLine, r->label);
labelLine[19] = '\0';
printf (" %s %s\n", treeLine, labelLine);
}
free (downPass);
return (NO_ERROR);
}
#if !defined (CONTREE)
void SortCompatParts (int *item, unsigned *item2, double *item3, int count)
{
SortCompatParts2 (item, item2, item3, 0, count-1);
}
void SortCompatParts2 (int *item, unsigned *item2, double *item3, int left, int right)
{
register int i, j, k, x, y;
unsigned yU;
double yD;
i = left;
j = right;
x = item[((left+right)/2)];
do
{
while (item[i] > x && i < right)
i++;
while (x > item[j] && j > left)
j--;
if (i <= j)
{
y = item[i];
item[i] = item[j];
item[j] = y;
for (k = 0; k<nUnsignedNeeded; k++)
{
yU = item2[i*nUnsignedNeeded+k];
item2[i*nUnsignedNeeded+k] = item2[j*nUnsignedNeeded+k];
item2[j*nUnsignedNeeded+k] = yU;
}
yD = item3[i];
item3[i] = item3[j];
item3[j] = yD;
i++;
j--;
}
} while (i <= j);
if (left < j)
SortCompatParts2 (item, item2, item3, left, j);
if (i < right)
SortCompatParts2 (item, item2, item3, i, right);
}
#endif
void SortParts (int *item, int count)
{
SortParts2 (item, 0, count-1);
}
void SortParts2 (int *item, int left, int right)
{
register int i, j, k;
unsigned yU;
double x, y;
i = left;
j = right;
x = item[(left+right)/2];
do
{
while (item[i] > x && i < right)
i++;
while (x > item[j] && j > left)
j--;
if (i <= j)
{
y = item[i];
item[i] = item[j];
item[j] = y;
y = aBrlens[i];
aBrlens[i] = aBrlens[j];
aBrlens[j] = y;
y = aOldBrlens[i];
aOldBrlens[i] = aOldBrlens[j];
aOldBrlens[j] = y;
y = sBrlens[i];
sBrlens[i] = sBrlens[j];
sBrlens[j] = y;
for (k = 0; k<nUnsignedNeeded; k++)
{
yU = treePartsFound[i*nUnsignedNeeded + k];
treePartsFound[i*nUnsignedNeeded + k] = treePartsFound[j*nUnsignedNeeded + k];
treePartsFound[j*nUnsignedNeeded + k] = yU;
}
i++;
j--;
}
} while (i <= j);
if (left < j)
SortParts2 (item, left, j);
if (i < right)
SortParts2 (item, i, right);
}
void SortVector (double *item, int count)
{
SortVector2 (item, 0, count-1);
}
void SortVector2 (double *item, int left, int right)
{
register int i, j;
double yD, x;
i = left;
j = right;
x = item[((left+right)/2)];
do
{
while (item[i] < x && i < right)
i++;
while (x < item[j] && j > left)
j--;
if (i <= j)
{
yD = item[i];
item[i] = item[j];
item[j] = yD;
i++;
j--;
}
} while (i <= j);
if (left < j)
SortVector2 (item, left, j);
if (i < right)
SortVector2 (item, i, right);
}
int StandID (char nuc)
{
char n;
n = nuc;
if (n == '0')
{
return 1;
}
else if (n == '1')
{
return 2;
}
else if (n == 'N' || n == 'n')
{
return 3;
}
else if (n == gapChar)
{
return 3;
}
else if (n == missingChar)
{
return 3;
}
/*else if (n == '2')
{
return 4;
}
else if (n == '3')
{
return 8;
}
else if (n == '4')
{
return 16;
}
else if (n == '5')
{
return 32;
}
else if (n == '6')
{
return 64;
}
else if (n == '7')
{
return 128;
}
else if (n == '8')
{
return 256;
}
else if (n == '9')
{
return 512;
}
else if (n == 'N' || n == 'n')
{
return 1023;
}
else if (n == gapChar)
{
return 1023;
}
else if (n == missingChar)
{
return 1023;
}*/
else
return -1;
}
int SummarizeParams (void)
{
int i, rc, tokenType, commandNumber, actionType, inError, isCommented;
char s[STRING_LENGTH];
command_list *q;
FILE *fp, *fopen();
if ((fp = fopen (sumParmFile, "r")) == NULL)
{
printf ("\n ERROR: Could not open file \"%s\"\n\n", sumParmFile);
rc = ERROR;
goto errorExit;
}
cmdPtr = &cmdList[0];
isCommented = NO;
inError = NO;
lineNumber = 0;
while (fgets (s, STRING_LENGTH, fp) != NULL)
{
lineNumber++;
//printf ("%s", s);
tokenP = &s[0];
do
{
GetToken (&tokenType);
if (tokenType == RETURNSYMBOL)
returnEncountered = YES;
commandNumber = ParseToken (tokenType);
if (commandNumber == NUMCOMMANDS + LEFTCOMMENT)
isCommented = YES;
if (*token && isCommented == NO)
{
//printf (" token = %s (%d %d)\n", token, tokenType, commandNumber);
actionType = IsCommandValid (commandNumber);
//printf (" actionType = %d\n", actionType);
if (actionType == ERROR_ACTION)
{
printf ("\n");
inError = YES;
if (tokenType != SEMICOLON)
printf (" ERROR: Invalid command \"%s\"\n", token);
if (expectedCommands[0] != -1)
{
printf (" EXPECTING: ");
i = 0;
while (expectedCommands[i] != -1)
{
q = &cmdList[expectedCommands[i]];
printf ("\"%s\"", q->cmdName);
i++;
if (expectedCommands[i+1] == -1 && expectedCommands[i] != -1)
printf (", or ");
else if (expectedCommands[i] != -1)
printf (", ");
if (i % 4 == 0)
printf ("\n ");
if (i % 4 == 0)
printf ("\n ");
}
printf ("\n");
}
//printf ("\n");
}
else if (actionType >= 0)
{
rc = DoAction (actionType);
if (rc == ERROR)
{
printf (" The problem is on line %d of the file named \"%s\"\n", lineNumber, sumTreeFile);
goto errorExit;
}
}
}
if (commandNumber == NUMCOMMANDS + RIGHTCOMMENT)
isCommented = NO;
} while (*token && inError == NO);
}
fclose (fp);
return (NO_ERROR);
errorExit:
#if defined (MORPH)
if (fp!=NULL)
fclose (fp);
#else
fclose (fp);
#endif
return (ERROR);
}
int SummarizeTrees (void)
{
int i, rc, tokenType, commandNumber, actionType, inError, isCommented;
char s[STRING_LENGTH];
command_list *q;
FILE *fp, *fopen();
if ((fp = fopen (sumTreeFile, "r")) == NULL)
{
printf ("\n ERROR: Could not open file \"%s\"\n\n", sumTreeFile);
rc = ERROR;
goto errorExit;
}
cmdPtr = &cmdList[0];
isCommented = NO;
inError = NO;
lineNumber = 0;
while (fgets (s, STRING_LENGTH, fp) != NULL)
{
lineNumber++;
//printf ("%s", s);
tokenP = &s[0];
do
{
GetToken (&tokenType);
if (tokenType == RETURNSYMBOL)
returnEncountered = YES;
commandNumber = ParseToken (tokenType);
if (commandNumber == NUMCOMMANDS + LEFTCOMMENT)
isCommented = YES;
if (*token && isCommented == NO)
{
//printf (" token = %s (%d %d)\n", token, tokenType, commandNumber);
actionType = IsCommandValid (commandNumber);
//printf (" actionType = %d\n", actionType);
if (actionType == ERROR_ACTION)
{
printf ("\n");
inError = YES;
if (tokenType != SEMICOLON)
printf (" ERROR: Invalid command \"%s\"\n", token);
if (expectedCommands[0] != -1)
{
printf (" EXPECTING: ");
i = 0;
while (expectedCommands[i] != -1)
{
q = &cmdList[expectedCommands[i]];
printf ("\"%s\"", q->cmdName);
i++;
if (expectedCommands[i+1] == -1 && expectedCommands[i] != -1)
printf (", or ");
else if (expectedCommands[i] != -1)
printf (", ");
if (i % 4 == 0)
printf ("\n ");
if (i % 4 == 0)
printf ("\n ");
}
printf ("\n");
}
//printf ("\n");
}
else if (actionType >= 0)
{
rc = DoAction (actionType);
if (rc == ERROR)
{
printf (" The problem is on line %d of the file named \"%s\"\n", lineNumber, sumTreeFile);
goto errorExit;
}
}
}
if (commandNumber == NUMCOMMANDS + RIGHTCOMMENT)
isCommented = NO;
} while (*token && inError == NO);
}
fclose (fp);
return (NO_ERROR);
errorExit:
#if defined (MORPH)
if (fp != NULL)
#endif
fclose (fp);
return (ERROR);
}
#if defined (CONTREE)
void WriteConTree (PolyNode *p, FILE *fp)
{
PolyNode *q;
if (p->anc != NULL)
if (p->anc->left == p)
fprintf (fp, "(");
for (q = p->left; q != NULL; q = q->sib)
{
if (q->anc != NULL) // added by JPH
if (q->anc->left != q)
fprintf (fp, ",");
WriteConTree (q, fp);
}
if (p->left == NULL)
{
if (foundBrlens == YES)
fprintf (fp, "%d:%lf", p->index+1, p->length);
else
fprintf (fp, "%d", p->index+1);
}
if (p->sib == NULL && p->anc != NULL)
{
if (foundBrlens == YES)
fprintf (fp, "):%lf", p->anc->length); // added "anc->" by JPH
else
fprintf (fp, ")");
}
}
#else
void WriteConTreeToScreen (ConTreeNode *p, FILE *fp)
{
ConTreeNode *q;
if (p->anc != NULL)
if (p->anc->left == p)
fprintf (fp, "(");
for (q = p->left; q != NULL; q = q->rightSib)
{
if (q->anc != NULL)
if (q->anc->left != q)
fprintf (fp, ",");
WriteConTreeToScreen (q, fp);
}
if (p->left == NULL)
{
if (foundBrlens == YES)
fprintf (fp, "%d:%lf", p->index+1, p->length);
else
fprintf (fp, "%d", p->index+1);
}
if (p->rightSib == NULL && p->anc != NULL)
{
if (foundBrlens == YES)
fprintf (fp, "):%lf", p->anc->length);
else
fprintf (fp, ")");
}
}
#endif
#if defined(__MWERKS__)
# pragma optimization_level reset
#endif
|
