/**
 * Author: Mark Larkin
 * 
 * Copyright (c) 2007 Des Higgins, Julie Thompson and Toby Gibson.  
 */
#ifdef HAVE_CONFIG_H
    #include "config.h"
#endif
#include <cctype>
#include <cstdio>
#include <iostream>
#include <fstream>
#include "CommandLineParser.h"
#include "../substitutionMatrix/globalmatrix.h"
#include "general/Utility.h"
#include "general/statsObject.h"



using namespace std;

namespace clustalw
{

CommandLineParser::CommandLineParser(StringArray* args, bool xmenus)
   :setOptions(-1),
    setHelp(-1),
    setFullHelp(-1),
    setQuiet(-1),
    setInteractive(-1),
    setBatch(-1),
    setGapOpen(-1),
    setGapExtend(-1),
    setPWGapOpen(-1),
    setPWGapExtend(-1),
    setOutOrder(-1),
    setBootLabels(-1),
    setPWMatrix(-1),
    setMatrix(-1),
    setPWDNAMatrix(-1),
    setDNAMatrix(-1),
    setNegative(-1),
    setNoWeights(-1),
    setOutput(-1),
    setOutputTree(-1),
    setQuickTree(-1),
    setType(-1),
    setCase(-1),
    setSeqNo(-1),
    setSeqNoRange(-1),
    setRange(-1),
    setTransWeight(-1),
    setSeed(-1),
    setScore(-1),
    setWindow(-1),
    setKtuple(-1),
    setKimura(-1),
    setTopDiags(-1),
    setPairGap(-1),
    setTossGaps(-1),
    setNoPGap(-1),
    setNoHGap(-1),
    setNoVGap(-1),
    setHGapRes(-1),
    setUseEndGaps(-1),
    setMaxDiv(-1),
    setGapDist(-1),
    setDebug(-1),
    setOutfile(-1),
    setInfile(-1),
    setProfile1(-1),
    setProfile2(-1),
    setAlign(-1),
    setConvert(-1),
    setNewTree(-1),
    setUseTree(-1),
    setNewTree1(-1),
    setUseTree1(-1),
    setNewTree2(-1),
    setUseTree2(-1),
    setBootstrap(-1),
    setTree(-1),
    setProfile(-1),
    setSequences(-1),
    setSecStruct1(-1),
    setSecStruct2(-1),
    setSecStructOutput(-1),
    setHelixGap(-1),
    setStrandGap(-1),
    setLoopGap(-1),
    setTerminalGap(-1),
    setHelixEndIn(-1),
    setHelixEndOut(-1),
    setStrandEndIn(-1),
    setStrandEndOut(-1),
    profileType(PROFILE),
    setDoIteration(-1),
    setNumIterations(-1),
    setTreeAlgorithm(-1),
    setMaxSeqLen(-1),
    setStatsFile(-1),
    setOutputPim(-1)
{
    int ctr=0;
    
    // The rest of the variables are arrays!
    try
    {
        clustalObj = new Clustal();
        
        // selecting the size prevents the resizing of the vector which is expensive. 
        typeArg = new StringArray(3);
        bootLabelsArg = new StringArray(3);
        outOrderArg = new StringArray(3);
        caseArg = new StringArray(3);
        seqNoArg = new StringArray(3);
        seqNoRangeArg = new StringArray(3);
        scoreArg = new StringArray(3);
        outputArg = new StringArray(7);
        outputTreeArg = new StringArray(5);
        outputSecStrArg = new StringArray(5);
        cmdLineType = new StringArray(6);
        clusterAlgorithm = new StringArray(3);
        iterationArg = new StringArray(4);
        
        params = new StringArray; // Wait until I need it!!!!!!!!!
        paramArg = new StringArray;
    }
    catch(const exception &ex)
    {
        cerr << ex.what() << endl;
        cerr << "Terminating program. Cannot continue" << std::endl;
        exit(1);
    }
                           
    (*typeArg)[0] = "protein";
    (*typeArg)[1] = "dna";
    (*typeArg)[2] = "";
        
    (*bootLabelsArg)[0] = "node";
    (*bootLabelsArg)[1] = "branch";
    (*bootLabelsArg)[2] = "";
    
    (*outOrderArg)[0] = "input";
    (*outOrderArg)[1] = "aligned";
    (*outOrderArg)[2] = "";
    
    (*caseArg)[0] = "lower";
    (*caseArg)[1] = "upper";
    (*caseArg)[2] = "";
    
    (*seqNoArg)[0] = "off";
    (*seqNoArg)[1] = "on";
    (*seqNoArg)[2] = "";
    
    (*seqNoRangeArg)[0] = "off";
    (*seqNoRangeArg)[1] = "on";
    (*seqNoRangeArg)[2] = "";
        
    (*scoreArg)[0] = "percent";
    (*scoreArg)[1] = "absolute";
    (*scoreArg)[2] = "";
    
    (*outputArg)[0] = "gcg";
    (*outputArg)[1] = "gde";
    (*outputArg)[2] = "pir";
    (*outputArg)[3] = "phylip";
    (*outputArg)[4] = "nexus";
    (*outputArg)[5] = "fasta";
    (*outputArg)[6] = "";
    
    (*outputTreeArg)[0] = "nj";
    (*outputTreeArg)[1] = "phylip";
    (*outputTreeArg)[2] = "dist";
    (*outputTreeArg)[3] = "nexus";
    (*outputTreeArg)[4] = "";
    
    (*outputSecStrArg)[0] = "structure";
    (*outputSecStrArg)[1] = "mask";
    (*outputSecStrArg)[2] = "both";
    (*outputSecStrArg)[3] = "none";
    (*outputSecStrArg)[4] = "";
    
    (*cmdLineType)[0] = " ";
    (*cmdLineType)[1] = "=n ";
    (*cmdLineType)[2] = "=f ";
    (*cmdLineType)[3] = "=string ";
    (*cmdLineType)[4] = "=filename ";
    (*cmdLineType)[5] = "";
    
    (*clusterAlgorithm)[0] = "nj";
    (*clusterAlgorithm)[1] = "upgma";
    (*clusterAlgorithm)[2] = "";

    (*iterationArg)[0] = "tree";
    (*iterationArg)[1] = "alignment";
    (*iterationArg)[2] = "none";
    (*iterationArg)[3] = "";
        
    userMatrixName = "";
    pwUserMatrixName = "";
    DNAUserMatrixName = "";
    pwDNAUserMatrixName = "";
    
    clustalTreeName = "";
    distTreeName = "";
    phylipTreeName = "";
    nexusTreeName = "";
    p1TreeName = "";
    p2TreeName = "";
    pimName = "";

    // NOTE there were only 3 params for the last one, so I put in NULL for the 4th.
    ctr=0;
    cmdLineFile[ctr++] = getCmdLineDataStruct("infile", &setInfile, FILARG, NULL);
    cmdLineFile[ctr++] = getCmdLineDataStruct("profile1", &setProfile1, FILARG, NULL);
    cmdLineFile[ctr++] = getCmdLineDataStruct("profile2", &setProfile2, FILARG, NULL);
    cmdLineFile[ctr++] = getCmdLineDataStruct("", NULL, -1, NULL);
    // FIXME: final ctr index is hardcoded in CommandLineParser
    
    ctr=0;
    cmdLineVerb[ctr++] = getCmdLineDataStruct("help", &setHelp, NOARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("fullhelp", &setFullHelp, NOARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("quiet", &setQuiet, NOARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("check", &setHelp, NOARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("options", &setOptions, NOARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("align", &setAlign, NOARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("newtree", &setNewTree, FILARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("usetree", &setUseTree, FILARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("newtree1", &setNewTree1, FILARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("usetree1", &setUseTree1, FILARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("newtree2", &setNewTree2, FILARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("usetree2", &setUseTree2, FILARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("bootstrap", &setBootstrap, NOARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("tree", &setTree, NOARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("quicktree", &setQuickTree, NOARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("convert", &setConvert, NOARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("interactive", &setInteractive, NOARG, NULL);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("batch", &setBatch, NOARG, NULL);
    // Mark change 16-feb-2007 I added options for doing LE and iteration
    cmdLineVerb[ctr++] = getCmdLineDataStruct("iteration", &setDoIteration, 
                                           OPTARG, iterationArg);
    cmdLineVerb[ctr++] = getCmdLineDataStruct("", NULL, -1, NULL);
    // FIXME: final ctr index is hardcoded in CommandLineParser.h
    
    // NOTE Start back here!!!!!!!!!!!!
    ctr=0;
    cmdLinePara[ctr++] = getCmdLineDataStruct("type", &setType, OPTARG, typeArg);
    cmdLinePara[ctr++] = getCmdLineDataStruct("profile", &setProfile, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("sequences", &setSequences, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("matrix", &setMatrix, FILARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("dnamatrix", &setDNAMatrix, FILARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("negative", &setNegative, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("noweights", &setNoWeights, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("gapopen", &setGapOpen, FLTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("gapext", &setGapExtend, FLTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("endgaps", &setUseEndGaps, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("nopgap", &setNoPGap, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("nohgap", &setNoHGap, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("novgap", &setNoVGap, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("hgapresidues", &setHGapRes, STRARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("maxdiv", &setMaxDiv, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("gapdist", &setGapDist, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("pwmatrix", &setPWMatrix, FILARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("pwdnamatrix", &setPWDNAMatrix, FILARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("pwgapopen", &setPWGapOpen, FLTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("pwgapext", &setPWGapExtend, FLTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("ktuple", &setKtuple, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("window", &setWindow, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("pairgap", &setPairGap, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("topdiags", &setTopDiags, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("score", &setScore, OPTARG, scoreArg);
    cmdLinePara[ctr++] = getCmdLineDataStruct("transweight", &setTransWeight, FLTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("seed", &setSeed, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("kimura", &setKimura, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("tossgaps", &setTossGaps, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("bootlabels", &setBootLabels, OPTARG,
                                             bootLabelsArg);
    cmdLinePara[ctr++] = getCmdLineDataStruct("debug", &setDebug, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("output", &setOutput, OPTARG, outputArg);
    cmdLinePara[ctr++] = getCmdLineDataStruct("outputtree", &setOutputTree, OPTARG,
                                             outputTreeArg);
    cmdLinePara[ctr++] = getCmdLineDataStruct("outfile", &setOutfile, FILARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("outorder", &setOutOrder, OPTARG, outOrderArg);
    cmdLinePara[ctr++] = getCmdLineDataStruct("case", &setCase, OPTARG, caseArg);
    cmdLinePara[ctr++] = getCmdLineDataStruct("seqnos", &setSeqNo, OPTARG, seqNoArg);
    cmdLinePara[ctr++] = getCmdLineDataStruct("seqno_range", &setSeqNoRange, OPTARG,
                                             seqNoRangeArg);
    cmdLinePara[ctr++] = getCmdLineDataStruct("range", &setRange, STRARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("nosecstr1", &setSecStruct1, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("nosecstr2", &setSecStruct2, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("secstrout", &setSecStructOutput, OPTARG,
                                             outputSecStrArg);
    cmdLinePara[ctr++] = getCmdLineDataStruct("helixgap", &setHelixGap, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("strandgap", &setStrandGap, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("loopgap", &setLoopGap, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("terminalgap", &setTerminalGap, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("helixendin", &setHelixEndIn, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("helixendout", &setHelixEndOut, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("strandendin", &setStrandEndIn, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("strandendout",&setStrandEndOut, INTARG, NULL);
    // NOTE these one was added to test the new LE scoring and iterations
    cmdLinePara[ctr++] = getCmdLineDataStruct("numiter",&setNumIterations, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("clustering", &setTreeAlgorithm, OPTARG,
                                           clusterAlgorithm);
    cmdLinePara[ctr++] = getCmdLineDataStruct("maxseqlen", &setMaxSeqLen, INTARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("stats", &setStatsFile, FILARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("pim", &setOutputPim, NOARG, NULL);
    cmdLinePara[ctr++] = getCmdLineDataStruct("", NULL, -1, NULL);
    // FIXME: final ctr index is hardcoded in CommandLineParser
    
    parseParams(args, xmenus);
}

CommandLineParser::~CommandLineParser()
{
    // Free up menory used here!
    // NOTE any dynamically allocated memory (new) must be deleted.
    delete clustalObj;
    delete typeArg;
    delete bootLabelsArg;
    delete outOrderArg;
    delete caseArg;
    delete seqNoArg;
    delete seqNoRangeArg;
    delete scoreArg;
    delete outputArg;
    delete outputTreeArg;
    delete outputSecStrArg;
    delete cmdLineType;        
    delete params;
    delete paramArg;   
    delete clusterAlgorithm;
    delete iterationArg;
}

void CommandLineParser::parseParams(StringArray* args, bool xmenus)
{
    #if DEBUGFULL 
        if(logObject && DEBUGLOG)
        {
            logObject->logMsg("Parsing Command line Parameters!\n");
        }
    #endif
        
    int i, j, temp;
    //int len;
    //static int cl_error_code = 0;
    //char path[FILENAMELEN];
    int numparams = 0;

    bool doAlign, doConvert, doAlignUseOldTree, doGuideTreeOnly, doTreeFromAlign, 
         doBootstrap, doProfileAlign, doSomething;

    if (!xmenus && userParameters->getDisplayInfo())
    {
        cout <<  std::endl << std::endl << std::endl;
        cout << " CLUSTAL " << userParameters->getRevisionLevel() 
             << " Multiple Sequence Alignments" << std::endl << std::endl << std::endl;
    }

    doAlign = doConvert = doAlignUseOldTree = doGuideTreeOnly = doTreeFromAlign = false;
    doBootstrap = doProfileAlign = doSomething = false; 
    
    numparams = checkParam(args, params, paramArg);
    
    if (numparams < 0) 
    {
        exit(1);
    }

//**********************************************************************
//*** Note: This part of the code is to print out the options with  ****
//*** their expected value types/ranges                             ****
//**********************************************************************
    
    if(setHelp != -1) 
    {
        userParameters->setHelpFlag(true);
        if (xmenus) {
            // gui will display help
            // but parse rest of args anyway and don't return
        } else {
            clustalObj->getHelp('9');
            exit(1);
        }
    }

    if(setFullHelp != -1) 
    {
        userParameters->setFullHelpFlag(true);
        if (xmenus) {
            // gui will handle this
            // but parse rest of args anyway and don't return
        } else {
            clustalObj->getFullHelp();
            exit(1);
        }
    }

    if(setQuiet != -1) 
    {
        userParameters->setDisplayInfo(false);
        utilityObject->beQuiet(true);
    } else {
        userParameters->setDisplayInfo(true);
        utilityObject->beQuiet(false);
    }

        
    // need to check maxseqlen before reading input file
    if (setMaxSeqLen != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting max allowed sequence length.");
            }    
        #endif      
        temp = 0;
        if((*paramArg)[setMaxSeqLen].length() > 0)
        {
            if (sscanf((*paramArg)[setMaxSeqLen].c_str(),"%d", &temp) != 1) 
            {
                reportBadOptionAndExit("maxseqlen", "integer");
            }
        }
        if(temp > 0)
        {
            userParameters->setMaxAllowedSeqLength(temp);
        }
        else
        {
            cerr << "Cannot use a negative value for maximum sequence length. Using default"  << std::endl;
        }
        
    }

    if (setStatsFile != -1)
    {
        if((*paramArg)[setStatsFile].length() > 0) 
        {
            statsObject->setEnabled(true);
            statsObject->setStatsFile((*paramArg)[setStatsFile]);
        }
    }


    if (setOutputPim != -1)
    {
            userParameters->setOutputPim(true);
    }


    /*if(setDoIteration != -1)
    {
        userParameters->setDoRemoveFirstIteration(true);
    }*/
    
    if(setDoIteration != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting iteration parameter.");
            }
        #endif
        if((*paramArg)[setDoIteration].length() > 0) 
        { 
            temp = findMatch((*paramArg)[setDoIteration], iterationArg, 3);
            if(temp == 0)
            {
                userParameters->setDoRemoveFirstIteration(TREE);
            }
            else if(temp == 1)
            {
                userParameters->setDoRemoveFirstIteration(ALIGNMENT);
            }
            else if(temp == 2)
            {               
                userParameters->setDoRemoveFirstIteration(NONE);
            }
            else
            {
                cerr << "Unknown option for iteration. Setting to NONE"  << std::endl;
                userParameters->setDoRemoveFirstIteration(NONE);
            }
        }
    }    
    if(setOptions != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("Displaying options!\n");
            }
        #endif
                
        cout << "clustalw option list:-" << std::endl;
        
        for (i = 0; cmdLineVerb[i].str[0] != '\0'; i++) 
        {
            cout << "\t\t" << default_commandsep << cmdLineVerb[i].str 
                 << (*cmdLineType)[cmdLineVerb[i].type];

            if (cmdLineVerb[i].type == OPTARG) 
            {
                if (cmdLineVerb[i].arg !=  NULL)
                {     
                    cout << "=" << cmdLineVerb[i].arg->at(0);
                    for(j = 1; j < (int)cmdLineVerb[i].arg->size() - 1; j++)
                    {
                        cout << " OR " << cmdLineVerb[i].arg->at(j);
                    }
                }
            }
            cout << std::endl;
        }
        for (i = 0; cmdLineFile[i].str[0] != '\0'; i++) 
        {
            cout<<"\t\t" << default_commandsep << cmdLineFile[i].str 
                << (*cmdLineType)[cmdLineFile[i].type];
                
            if (cmdLineFile[i].type == OPTARG) 
            {
                if (cmdLineFile[i].arg !=  NULL)
                {
                    
                    cout << "=" << cmdLineFile[i].arg->at(0);
                    for(j = 1; j < (int)cmdLineFile[i].arg->size() - 1; j++)
                    {
                        cout << " OR " << cmdLineFile[i].arg->at(j);
                    }
                }
            }
            cout << std::endl;
        }
        for (i = 0; cmdLinePara[i].str[0] != '\0'; i++) 
        {
            cout <<"\t\t" << default_commandsep << cmdLinePara[i].str 
                 << (*cmdLineType)[cmdLinePara[i].type];
     
            if (cmdLinePara[i].type == OPTARG) 
            {
                if (cmdLinePara[i].arg !=  NULL)
                {
                    
                    cout << "=" << cmdLinePara[i].arg->at(0);
                    for(j = 1; j < (int)cmdLinePara[i].arg->size() - 1; j++)
                    {
                        cout << " OR " << cmdLinePara[i].arg->at(j);
                    }
                }
            }
            cout << std::endl;
        }
        exit(1);
    }


//*****************************************************************************
//  Check to see if sequence type is explicitely stated..override ************
// the automatic checking (DNA or Protein).   /type=d or /type=p *************
//****************************************************************************

    if(setType != -1)
    {
        string msg;
        if(((*paramArg)[setType].length()) > 0) 
        {
            temp = findMatch((*paramArg)[setType], typeArg, 2);
            if(temp == 0) 
            { 
                userParameters->setDNAFlag(false);
                userParameters->setExplicitDNAFlag(true);
                msg = "Sequence type explicitly set to Protein";
                cout << msg << std::endl;
            }
            else if(temp == 1) 
            {
                msg = "Sequence type explicitly set to DNA";
                cout << msg << std::endl;
                userParameters->setDNAFlag(true);
                userParameters->setExplicitDNAFlag(true);
            }
            else
            {
                msg = "Unknown sequence type " + (*paramArg)[setType];
                cerr << std::endl << msg << endl;
            }
            #if DEBUGFULL 
                if(logObject && DEBUGLOG)
                {
                    logObject->logMsg(msg);
                }
            #endif            
        }
    }


//***************************************************************************
//   check to see if 1st parameter does not start with '/' i.e. look for an *
//   input file as first parameter.   The input file can also be specified  *
//   by /infile=fname.                                                      *
//***************************************************************************
// JULIE - moved to checkParam()
  //  if(paramstr[0] != '/') 
  //  {
  //      strcpy(seqName, params[0]);
  //  }


//*************************************************
//  Look for /infile=file.ext on the command line *
//*************************************************

    if(setInfile != -1) 
    {
        if((*paramArg)[setInfile].length() <= 0) 
        {
            exitWithErrorMsg("Bad sequence file name");
        }
        userParameters->setSeqName((*paramArg)[setInfile]);

        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                string msg = "Sequence file name (seqName) has been set to ";
                msg += userParameters->getSeqName();             
                logObject->logMsg(msg);
            }
        #endif        
    }
    
    // NOTE keep an eye on this part to see if it works.
    if(userParameters->getSeqName() != "") 
    {
        // NOTE I will need to cheack if it has been successful before setting
        // doSomething to true.
        int code;
        code = clustalObj->commandLineReadSeq(1);
        if(code == OK)
        {
            doSomething = true;
        }
        else
        {
            doSomething = false;
            exit(1);
        }
    }

    // NOTE call the other function to set the parameter values!!
    setOptionalParam();

//*********************************************************
// Look for /profile1=file.ext  AND  /profile2=file2.ext *
// You must give both file names OR neither.             *
//********************************************************


    if(setProfile1 != -1) 
    {
        if((*paramArg)[setProfile1].length() <= 0) 
        {
            exitWithErrorMsg("Bad profile 1 file name");
        }
                
        clustalObj->profile1Input((*paramArg)[setProfile1]);
    }

    if(setProfile2 != -1) 
    {
        if((*paramArg)[setProfile2].length() <= 0) 
        {
            exitWithErrorMsg("Bad profile 2 file name");
        }
        if(userParameters->getProfile1Empty()) 
        {
            exitWithErrorMsg("Only 1 profile file (profile 2) specified.");
        }
        
        clustalObj->profile2Input((*paramArg)[setProfile2]);
        doSomething = doProfileAlign = true; 
    }

//************************************************************************
// Look for /tree or /bootstrap or /align or /usetree ******************
//************************************************************************

    if (setBatch != -1)
    {
        userParameters->setInteractive(false);
    }

    if (setInteractive != -1)
    {
        userParameters->setInteractive(true);
        if (setQuiet!=-1) {
            cout << "interactive menu: overriding " << default_commandsep << "quiet" << std::endl;
            userParameters->setDisplayInfo(true);
            utilityObject->beQuiet(false);
        }
    }

    if (userParameters->getInteractive()) 
    {
        setTree = -1;
        setBootstrap = -1;
        setAlign = -1;
        setUseTree = -1;
        setUseTree1 = -1;
        setUseTree2 = -1;
        setNewTree = -1;
        setConvert = -1;
    }

    if(setTree != -1 )
    {
        if(userParameters->getEmpty()) 
        {
            exitWithErrorMsg("Cannot draw tree.  No input alignment file");
        }
        else
        { 
            doTreeFromAlign = true;
        }
    }

    if(setBootstrap != -1)
    {
        if(userParameters->getEmpty()) 
        {
            exitWithErrorMsg("Cannot bootstrap tree. No input alignment file");
        }
        else 
        {
            temp = 0;
            // Check if there is anything in the string!
            if((*paramArg)[setBootstrap].length() > 0)
            {
                if (sscanf((*paramArg)[setBootstrap].c_str(), "%d", &temp) != 1) 
                {
                    reportBadOptionAndExit("bootstrap", "integer");
                }
            }
            if(temp > 0)
            {    
                userParameters->setBootNumTrials(temp);
            }
            doBootstrap = true;
        }
    }

    if(setAlign != -1)
    {
        if(userParameters->getEmpty()) 
        {
            exitWithErrorMsg("Cannot align sequences.  No input file");
        }
        else
        { 
            doAlign = true;
        }
    }

    if(setConvert != -1)
    {
        if(userParameters->getEmpty()) 
        {
            exitWithErrorMsg("Cannot convert sequences.  No input file");
        }
        else
        { 
            doConvert = true;
        }
    }
 
    if(setUseTree != -1)
    {
        if(userParameters->getEmpty()) 
        {
            exitWithErrorMsg("Cannot align sequences.  No input file");
        }
        else  
        {
           if((*paramArg)[setUseTree].length() == 0) 
           {
               exitWithErrorMsg("Cannot align sequences.  No tree file specified");
           }
           else 
           {
               phylipTreeName = (*paramArg)[setUseTree];
           }
           userParameters->setUseTreeFile(true);
           doAlignUseOldTree = true;
        }
    }

    if(setNewTree != -1)
    {
        if(userParameters->getEmpty()) 
        {
            exitWithErrorMsg("Cannot align sequences.  No input file");
        }
        else  
        {
            if((*paramArg)[setNewTree].length() == 0) 
            {
                exitWithErrorMsg("Cannot align sequences.  No tree file specified");
            }
            else 
            {
                phylipTreeName = (*paramArg)[setNewTree];
            }
            userParameters->setNewTreeFile(true);
            doGuideTreeOnly = true;
        }
    }
 
    if(setUseTree1 != -1)
    {
        if(userParameters->getProfile1Empty()) 
        {
            exitWithErrorMsg("Cannot align profiles.  No input file");
        }
        else if(profileType == SEQUENCE) 
        {
            reportInvalidOptionAndExit("usetree1");
        }
        else  
        {
            if((*paramArg)[setUseTree1].length() == 0) 
            {
                exitWithErrorMsg("Cannot align profiles.  No tree file specified");
            }
            else 
            {
                p1TreeName = (*paramArg)[setUseTree1];
            }
            userParameters->setUseTree1File(true);
            doAlignUseOldTree = true;
        }
    }

    if(setNewTree1 != -1)
    {
        if(userParameters->getProfile1Empty()) 
        {
            exitWithErrorMsg("Cannot align profiles.  No input file");
        }
        else if(profileType == SEQUENCE) 
        {
            reportInvalidOptionAndExit("newtree1");
        }
        else  
        {
           if((*paramArg)[setNewTree1].length() == 0) 
           {
               exitWithErrorMsg("Cannot align profiles. No tree file specified");
           }
           else 
           {
                p1TreeName = (*paramArg)[setNewTree1];
           }
           userParameters->setNewTree1File(true);
        }
    }
 
    if(setUseTree2 != -1)
    {
        if(userParameters->getProfile2Empty()) 
        {
            exitWithErrorMsg("Cannot align profiles.  No input file");
        }
        else if(profileType == SEQUENCE) 
        {
            reportInvalidOptionAndExit("usetree2");
        }
        else  
        {
            if((*paramArg)[setUseTree2].length() == 0) 
            {
                exitWithErrorMsg("Cannot align profiles.  No tree file specified");
            }
            else 
            {
                p2TreeName = (*paramArg)[setUseTree2];
            }
            userParameters->setUseTree2File(true);
            doAlignUseOldTree = true;
        }
    }

    if(setNewTree2 != -1)
    {
        if(userParameters->getProfile2Empty()) 
        {
            exitWithErrorMsg("Cannot align profiles.  No input file");
        }
        else if(profileType == SEQUENCE) 
        {
            reportInvalidOptionAndExit("newtree2");
        }
        else  
        {
            if((*paramArg)[setNewTree2].length() == 0) 
            {
                exitWithErrorMsg("Cannot align profiles.  No tree file specified");
            }
            else 
            {
                p2TreeName = (*paramArg)[setNewTree2];
            }
            userParameters->setNewTree2File(true);
        }
    }


    if( (!doTreeFromAlign) && (!doBootstrap) && (!userParameters->getEmpty()) && (!doProfileAlign) && 
      (!doAlignUseOldTree) && (!doGuideTreeOnly) && (!doConvert))
    { 
        doAlign = true;
    }

//** ? /quicktree 
    if(setQuickTree != -1)
    {
        userParameters->setQuickPairAlign(true);
    }

    // NOTE 
    if(userParameters->getDNAFlag()) 
    {
        userParameters->setDNAParams();
    }
    else 
    {
        userParameters->setProtParams();
    }
    
    if(userParameters->getInteractive()) 
    {
        if (!xmenus)
        { 
            userParameters->setMenuFlag(true);
        }
        return;
    }


    if(!doSomething) 
    {
        exitWithErrorMsg("No input file(s) specified");
    }


    

//***************************************************************************
// Now do whatever has been requested ***************************************
//***************************************************************************
// NOTE This part is obviously not done yet! Functions not working in Clustal!!!!
    #if DEBUGFULL 
        if(logObject && DEBUGLOG)
        {
            logObject->logMsg("Now doing the requested task(s)");
        }
    #endif
        
    if(doProfileAlign) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Doing profile align");
            }
        #endif        
        if (profileType == PROFILE)
        {
            #if DEBUGFULL 
                if(logObject && DEBUGLOG)
                {
                    logObject->logMsg("        Calling Profile_align in clustal obj!");
                }
            #endif            
            clustalObj->profileAlign(&p1TreeName, &p2TreeName);
        }
        else
        {
            #if DEBUGFULL 
                if(logObject && DEBUGLOG)
                {
                logObject->logMsg("        Calling sequencesAlignToProfile in clustal obj!");
                }
            #endif
            clustalObj->sequencesAlignToProfile(&phylipTreeName);
        }
    }

    else if(doAlign)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Doing Alignment");
            }
        #endif               
        clustalObj->align(&phylipTreeName);
    }

    else if(doConvert) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Doing filetype conversion");
            }
        #endif                  
        clustalObj->outputNow();
    }

    else if (doAlignUseOldTree)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Doing Alignment only");
            }
        #endif                 
        clustalObj->doAlignUseOldTree(&phylipTreeName);
    }

    else if(doGuideTreeOnly)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Doing tree only");
            }
        #endif               
        clustalObj->doGuideTreeOnly(&phylipTreeName);
    }

    else if(doTreeFromAlign)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {   
                logObject->logMsg("    Doing tree");
            }
        #endif                  
        clustalObj->phylogeneticTree(&phylipTreeName, &clustalTreeName, &distTreeName,
                                     &nexusTreeName, pimName);
    }

    else if(doBootstrap)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Doing Bootstrap");
            }
        #endif            
            clustalObj->bootstrapTree(&phylipTreeName, &clustalTreeName, &nexusTreeName);
    }

    cout << std::endl;
    
}



int CommandLineParser::checkParam(StringArray* args, StringArray* params,
                                  StringArray* paramArg)
{
    int len, i, j, nameFirst, num;
    //int k;
    vector<int> match;
    match.resize(MAXARGS);
    bool name1 = false;
    
    #if DEBUGFULL 
        if(logObject && DEBUGLOG)
        {
            logObject->logMsg("Checking Parameters!");
        }
    #endif
        
    if(args->size() == 0) // NOTE I think this will work better!
    {
        cout << "The argument list is empty\n";
        return 0;
    }

    // AW: first arg is an input file if it doesnt start with commandsep
    if (VALID_COMMAND_SEP.find((*args)[0][0], 0) == string::npos)
    {
        name1 = true;
        params->push_back((*args)[0]); // Put the string at the back of this vector.
        paramArg->push_back(""); // Push a blank string onto the first element.
    }
    else // It is not a file name
    {
        params->push_back((*args)[0].substr(1));
    }
    
    for (i = 1; i < (int)args->size(); i++) 
    {
        params->push_back(""); // Empty string!

        for(j = 0; j < (int)(*args)[i].length() - 1; j++)
        {
            if(isprint((*args)[i][j + 1])) // Character printable?
            {
                // We start at j + 1 because each option should begin with commandsep
                (*params)[i].append((*args)[i].substr(j + 1, 1));
            }
        }
    }
    num = i;


    // AW:
    // params are now setup
    // extract paramArgs in next step

    
    if ((int)args->size() > MAXARGS)
    {
        cerr << "Error: too many command line arguments\n";
        return(-1);
    }
    /*
      special case - first parameter is input fileName
    */
    nameFirst = 0;
    if(name1 == true) // If name of file is first argument
    {
        userParameters->setSeqName((*params)[0]);
        /* Andreas Wilm (UCD) 2008-03-19:
           conversion nowadays unnecessary and makes trouble
           
           /@  JULIE
           convert to lower case now
           @/
           #ifndef UNIX
           if(logObject && DEBUGLOG)
           {
           logObject->logMsg("Converting seqName to lower case.\n");
           }         
           string temp = ConvertStringToLower(userParameters->getSeqName());
           userParameters->setSeqName(temp);
           #endif
        */
        nameFirst = 1;
    }
  
    // NOTE if name first we should start at the 2nd element in paramArg
    // This loop is used to set up the paramArg vector!
    for (i = nameFirst; i < num; i++) 
    {
        bool has_arg=false;
        paramArg->push_back(""); // Push a new empty string on.
        len = (*params)[i].length();
        for(j = 0; j < len; j++)
        {
            if((*params)[i][j] == '=') 
            {
                has_arg=true;
                (*paramArg)[i].assign((*params)[i].substr(j + 1, len - j -1));               
                // Trim off the bit from the '=' to the end, and put all in lower case!
                (*params)[i].assign(ConvertStringToLower((*params)[i].substr(0, j)));
                break;
            }
        }
        // Andreas Wilm (UCD): 2008-03-19:
        // this convert nonarg params to lowercase (-QuIcKtReE etc)
        if (!has_arg) {
            (*params)[i].assign(ConvertStringToLower((*params)[i]));          
        }
    }

    if(paramArg->size() != params->size())
    {
        cerr << "There is something wrong with arguments. Lengths different\n";
        return -1;
    }
    
    /*
      for each parameter given on the command line, first search the list of recognised
      optional parameters....
    */
    for (i = 0; i < num; i++) 
    {
        if ((i == 0) && (name1 == true))
        { 
            continue;
        }
        j = 0;
        match[i] = -1;
        for(;;) 
        {
            if (cmdLinePara[j].str[0] == '\0')
            { 
                // Think this means we have not found it!
                break;
            }
            if (!(*params)[i].compare(cmdLinePara[j].str))
            {
                match[i] = j; // Match has been found!
                *cmdLinePara[match[i]].flag = i;
                
                if ((cmdLinePara[match[i]].type != NOARG) && ((*paramArg)[i] == "")) 
                {
                    cerr <<  "Error: parameter required for " << default_commandsep << (*params)[i] << endl;
                    return -1;
                
                /* Andreas Wilm (UCD) 2008-03-19:
                 *  conversion nowadays unnecessary and breaks things
                 *  
                 * //  JULIE
                 * //    convert parameters to lower case now, unless the parameter is a fileName
                 * #ifdef UNIX
                 * else if (cmdLinePara[match[i]].type != FILARG && (*paramArg)[i] != "")
                 * #endif
                */

                } else if (cmdLinePara[match[i]].type != FILARG && (*paramArg)[i] != "") {
                    if ((*paramArg)[i] != "") 
                    {
                        // lowercase arg if not a filename to support mixed case
                        (*paramArg)[i].assign(ConvertStringToLower((*paramArg)[i]));
                    }
                }
                break;
            }
            j++;
        }
    }
    
    /*
      ....then the list of recognised input files,.... 
    */
    for (i = 0; i < num; i++) 
    {
        if ((i == 0) && (name1 == true)) 
        {
            continue;
        }
        if (match[i] != -1) 
        {
            continue;
        }
        j = 0;
        for(;;) 
        {
            if (cmdLineFile[j].str[0] == '\0') 
            {
                // Have not found a match!
                break;
            }
            if (!(*params)[i].compare(cmdLineFile[j].str)) 
            {
                match[i] = j;
                *cmdLineFile[match[i]].flag = i;
                if ((cmdLineFile[match[i]].type != NOARG) &&
                                    ((*paramArg)[i] == "")) 
                {
                    cerr << "Error: parameter required for " << default_commandsep << (*params)[i] << endl;
                    return -1;
                }
                break;
            }
            j++;
        }
    }
    
    /*
      ....and finally the recognised verbs. 
    */
    for (i = 0; i < num; i++) 
    {
        if ((i == 0) && (name1 == true)) 
        {
            continue;
        }
        if (match[i] != -1) 
        {
            continue;
        }
        j = 0;
        for(;;) 
        {
            if (cmdLineVerb[j].str[0] == '\0') 
            {
                // Havent found it!
                break;
            }
            if (!(*params)[i].compare(cmdLineVerb[j].str)) 
            {
                match[i] = j;
                *cmdLineVerb[match[i]].flag = i;
                if ((cmdLineVerb[match[i]].type != NOARG) && ((*paramArg)[i] == "")) 
                {
                    cerr << "Error: parameter required for " << default_commandsep << (*params)[i] << endl;
                    return -1;
                }
                break;
            }
            j++;
        }
    }

    /*
      check for any unrecognised parameters.
    */
    for (i = 0; i < num; i++) 
    {
        if (match[i] == -1) 
        {
            cerr << "Error: unknown option " << default_commandsep << (*params)[i] << endl;
            return -1;
        }
    }
    return(num);
}

void CommandLineParser::setOptionalParam()
{
    int temp;
    int _ktup, _windgap, _signif, _window = 0;
    string _matrixname;
    //int c, i;
    float ftemp;
    //char tstr[100];

    #if DEBUGFULL 
        if(logObject && DEBUGLOG)
        {
            logObject->logMsg("Setting optional parameters.");
        }
    #endif      
    //****************************************************************************
    //* look for parameters on command line  e.g. gap penalties, k-tuple etc.    *
    //****************************************************************************
  
    // Mark change 16-2-2007. 
    
    if(setNumIterations != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting num iterations parameter.");
            }    
        #endif      
        temp = 0;
        if((*paramArg)[setNumIterations].length() > 0)
        {
            if (sscanf((*paramArg)[setNumIterations].c_str(),"%d", &temp) != 1) 
            {
                reportBadOptionAndExit("numiter", "int");
                temp = 0;
            }
        }
        if(temp > 0)
        {
            userParameters->setNumIterations(temp);
        }
        else
        {
            exitWithErrorMsg("Cannot use a negative value for number of iterations.");
        }
    }

    
    //** ? /score=percent or /score=absolute *
    if(setScore != -1)
    {    
        if((*paramArg)[setScore].length() > 0) 
        {
            temp = findMatch((*paramArg)[setScore], scoreArg, 2);
            if(temp == 0)
            {
                userParameters->setPercent(true);
                #if DEBUGFULL 
                    if(logObject && DEBUGLOG)
                    {
                        logObject->logMsg("    Setting score parameter = percent");
                    }
                #endif                 
            }
            else if(temp == 1)
            {
                userParameters->setPercent(false);
                #if DEBUGFULL 
                    if(logObject && DEBUGLOG)
                    {
                        logObject->logMsg("    Setting score parameter = absolute");
                    }
                #endif                 
            }
            else
            {
                cerr << "\nUnknown SCORE type: " << (*paramArg)[setScore] << endl;
                #if DEBUGFULL 
                    if(logObject && DEBUGLOG)
                    {
                        logObject->logMsg("    problem setting score type!!!!!");
                    }
                #endif                
            }
        }
    }
    // NOTE I decided to stay with sscanf for getting the int. Options in c++ no better.
    //** ? /seed=n *
    if(setSeed != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting seed parameter.");
            }    
        #endif      
        temp = 0;
        if((*paramArg)[setSeed].length() > 0)
        {
            if (sscanf((*paramArg)[setSeed].c_str(),"%d",&temp) != 1) 
            {
                reportBadOptionAndExit("seed", "integer");
            }
        }
        if(temp > 0)
        {
            userParameters->setBootRanSeed(temp);
        }
        cout<< "\ntemp = " << temp << "; seed = " << userParameters->getBootRanSeed() 
            << ";\n";
    }
  
    if(setTreeAlgorithm != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting clustering algorithm parameter.");
            }
        #endif
        if((*paramArg)[setTreeAlgorithm].length() > 0) 
        { 
            temp = findMatch((*paramArg)[setTreeAlgorithm], clusterAlgorithm, 2);
            if(temp == 0)
            {
                userParameters->setClusterAlgorithm(NJ);
            }
            else if(temp == 1)
            {
                userParameters->setClusterAlgorithm(UPGMA);
            }
            else
            {
                cerr << "Unknown option for clustering algorithm. Using default\n";
                userParameters->setClusterAlgorithm(NJ);
            }
        }
    }
    
    
    //** ? /output=PIR, GCG, GDE or PHYLIP *
    if(setOutput != -1)
    {
        
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting output parameter.");
            }
        #endif          
        if((*paramArg)[setOutput].length() > 0) 
        {
            temp = findMatch((*paramArg)[setOutput], outputArg, 6);
            if (temp >= 0 && temp <= 5) 
            {
                userParameters->setOutputClustal(false);
                userParameters->setOutputGCG(false);
                userParameters->setOutputPhylip(false);
                userParameters->setOutputNbrf(false);
                userParameters->setOutputGde(false);
                userParameters->setOutputNexus(false);
                userParameters->setOutputFasta(false);
            }
            switch (temp) 
            {
                case 0: // GCG 
                    userParameters->setOutputGCG(true);
                    break;
                case 1: // GDE 
                    userParameters->setOutputGde(true);
                    break;
                case 2: // PIR 
                    userParameters->setOutputNbrf(true);
                    break;
                case 3: // PHYLIP
                    userParameters->setOutputPhylip(true);
                    break;
                case 4: // NEXUS
                    userParameters->setOutputNexus(true);
                    break;
                case 5: // NEXUS
                    userParameters->setOutputFasta(true);
                    break;
                default:
                    // FIXME AW: 1.83 behaves the same, but shouldnt
                    // we exit here?
                    exitWithErrorMsg("Unknown OUTPUT type: " + (*paramArg)[setOutput]);
            }
        }
    }
    //** ? /outputtree=NJ or PHYLIP or DIST or NEXUS 
    if(setOutputTree != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting outputtree parameter.");
            }   
        #endif           
        if((*paramArg)[setOutputTree].length() > 0) 
        {
            temp = findMatch((*paramArg)[setOutputTree], outputTreeArg, 4);
            switch (temp) 
            {
                case 0: // NJ 
                    userParameters->setOutputTreeClustal(true);
                    break;
                case 1: // PHYLIP
                    userParameters->setOutputTreePhylip(true);
                    break;
                case 2: // DIST
                    userParameters->setOutputTreeDistances(true);
                    break;
                case 3: // NEXUS 
                    userParameters->setOutputTreeNexus(true);
                    break;
                default:
                    cerr << "\nUnknown OUTPUT TREE type: " 
                         << (*paramArg)[setOutputTree] << endl;
            }
        }
    }
    
    //** ? /profile (sets type of second input file to profile) 
    if(setProfile != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting profileType = PROFILE.");
            }         
        #endif 
        profileType = PROFILE;
    }
  
    //** ? /sequences (sets type of second input file to list of sequences)
    if(setSequences != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting profileType = SEQUENCE.");
            }         
        #endif
        profileType = SEQUENCE;
    } 
  
  
    //** ? /ktuple=n
    if(setKtuple != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting ktup parameter.");
            }
        #endif         
        _ktup = 0;
        if((*paramArg)[setKtuple].length() > 0)
        {
            if (sscanf((*paramArg)[setKtuple].c_str(),"%d",&_ktup)!=1) 
            {
                reportBadOptionAndExit("ktuple", "integer");
                _ktup = 0;
            }
        }
        
        if(_ktup > 0) 
        {
            if(userParameters->getDNAFlag()) 
            {
                if(_ktup <= 4) 
                {
                    userParameters->setKtup(_ktup);
                    userParameters->setDNAKtup(_ktup);
                    userParameters->setWindowGap(_ktup + 4);
                    userParameters->setDNAWindowGap(_ktup + 4);
                } else {
                    // see comment in bug 185
                    cerr << "WARNING: Ignoring invalid ktuple of " << _ktup <<  " (must be <=4)" << std::endl;
                }
            }
            else 
            {
                if(_ktup <= 2) 
                {
                    userParameters->setKtup(_ktup);
                    userParameters->setAAKtup(_ktup);
                    userParameters->setWindowGap(_ktup + 3);
                    userParameters->setAAWindowGap(_ktup + 3);
                    // AW: why set setDNAWindowGap? we are in AA mode
                    // userParameters->setDNAWindowGap(_ktup + 4);
                } else {
                    // see comment in bug 185
                   cerr << "WARNING: Ignoring invalid ktuple of " << _ktup << " (must be <=2)" << std::endl;
                }
            }
        }
    }
    
    //** ? /pairgap=n 
    if(setPairGap != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting pairgap parameter.");
            }
        #endif         
        _windgap = 0;
        if((*paramArg)[setPairGap].length() > 0)
        {
            if (sscanf((*paramArg)[setPairGap].c_str(),"%d",&_windgap)!=1) 
            {
                reportBadOptionAndExit("pairgap", "integer");
                _windgap = 0;
            }
            if(_windgap > 0)
            {
                if(userParameters->getDNAFlag()) 
                {
                    if(_windgap > userParameters->getKtup()) 
                    {
                        userParameters->setWindowGap(_windgap);
                        userParameters->setDNAWindowGap(_windgap);
                    }
                }
                else 
                {
                    if(_windgap > userParameters->getKtup()) 
                    {
                        userParameters->setWindowGap(_windgap);
                        userParameters->setAAWindowGap(_windgap);
                    }
                }
            }
        }
    } 
  
    //** ? /topdiags=n  
    if(setTopDiags != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting topdiags parameter.");
            }
        #endif          
        _signif = 0;
        if((*paramArg)[setTopDiags].length() > 0)
        {
            if (sscanf((*paramArg)[setTopDiags].c_str(),"%d",&_signif)!=1) 
            {
                reportBadOptionAndExit("topdiags", "integer");
            }
        }
        if(_signif > 0)
        {
            if(userParameters->getDNAFlag()) 
            {
                if(_signif > userParameters->getKtup()) 
                {
                    userParameters->setSignif(_signif);
                    userParameters->setDNASignif(_signif);
                }
            }
            else 
            {
                if(_signif > userParameters->getKtup()) 
                {
                    userParameters->setSignif(_signif);
                    userParameters->setAASignif(_signif);
                }
            }
        }
    }
    

    //** ? /window=n 
    if(setWindow != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting window parameter.");
            }
        #endif        
        _window = 0;
        if((*paramArg)[setWindow].length() > 0)
        {
            if (sscanf((*paramArg)[setWindow].c_str(),"%d",&_window)!=1) 
            {
                reportBadOptionAndExit("window", "integer");
                _window = 0;
            }
        }
        if(_window > 0)
        {
            if(userParameters->getDNAFlag()) 
            {
                if(_window > userParameters->getKtup()) 
                {
                    userParameters->setWindow(_window);
                    userParameters->setDNAWindow(_window);
                }
            }
            else 
            {
                if(_window > userParameters->getKtup()) 
                {
                    userParameters->setWindow(_window);
                    userParameters->setAAWindow(_window);
                }
            }
        }
    }
  
    //** ? /kimura 
    if(setKimura != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting kimura=true");
            }
        #endif        
        userParameters->setKimura(true);
    }
  
    //** ? /tossgaps 
    if(setTossGaps != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting tossgaps=true");
            }
        #endif        
        userParameters->setTossGaps(true);
    }
    
    //** ? /negative  
    if(setNegative != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting useNegMatrix=true");
            }         
        #endif 
        userParameters->setUseNegMatrix(true);
    }
  
    //** ? /noweights
    if(setNoWeights!= -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting noweights=true");
            }       
        #endif 
        userParameters->setNoWeights(true);
    }
  
  
    //** ? /pwmatrix=ID (user's file) 
    if(setPWMatrix != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting pwmatrix parameter.");
            }        
        #endif
        temp = (*paramArg)[setPWMatrix].length();
        if(temp > 0) 
        {
            _matrixname = ConvertStringToLower((*paramArg)[setPWMatrix]);
            if (_matrixname.compare("blosum") == 0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 1, Protein, Pairwise);
            }
            else if (_matrixname.compare("pam") == 0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 2, Protein, Pairwise);
            }
            else if (_matrixname.compare("gonnet") == 0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 3, Protein, Pairwise);
            }
            else if (_matrixname.compare("id") == 0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 4, Protein, Pairwise);
            }
            else 
            {
                char hackTempName[FILENAMELEN + 1];
                strcpy(hackTempName, (*paramArg)[setPWMatrix].c_str());
                
                if(subMatrix->getUserMatFromFile(hackTempName, Protein, Pairwise))
                {                      
                    subMatrix->setCurrentNameAndNum((*paramArg)[setPWMatrix], 5, 
                                                     Protein, Pairwise);
                    pwUserMatrixName = (*paramArg)[setPWMatrix];
                }
                else 
                    exit(1);
            }
        }
    }

        
    //** ? /matrix=ID (user's file)
    if(setMatrix != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting matrix parameter.");
            }       
        #endif 
        temp = (*paramArg)[setMatrix].length();
        if(temp > 0) 
        {
            _matrixname = ConvertStringToLower((*paramArg)[setMatrix]);

            if (_matrixname.compare("blosum")==0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 1, Protein, MultipleAlign);
            }
            else if (_matrixname.compare("pam")==0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 2, Protein, MultipleAlign);
            }
            else if (_matrixname.compare("gonnet")==0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 3, Protein, MultipleAlign);
            }
            else if (_matrixname.compare("id")==0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 4, Protein, MultipleAlign);
            }
            else 
            {
                char hackTempName[FILENAMELEN + 1];
                strcpy(hackTempName, (*paramArg)[setMatrix].c_str());
                                    
                if(subMatrix->getUserMatSeriesFromFile(hackTempName))
                {
                    subMatrix->setCurrentNameAndNum((*paramArg)[setMatrix], 4, 
                                                     Protein, MultipleAlign);
                    userMatrixName = (*paramArg)[setMatrix];
                }
                else 
                    exit(1);
            }
        }
    }

    //** ? /pwdnamatrix=ID (user's file)
    if(setPWDNAMatrix != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting pwdnamatrix parameter.");
            }       
        #endif 
        temp = (*paramArg)[setPWDNAMatrix].length();
        if(temp > 0) 
        {
            _matrixname = ConvertStringToLower((*paramArg)[setPWDNAMatrix]);

            if (_matrixname.compare("iub") == 0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 1, DNA, Pairwise);
            }
            else if (_matrixname.compare("clustalw") == 0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 2, DNA, Pairwise);
            }
            else 
            {
                char hackTempName[FILENAMELEN + 1];
                strcpy(hackTempName, (*paramArg)[setPWDNAMatrix].c_str());
                    
                if(subMatrix->getUserMatFromFile(hackTempName, DNA, Pairwise))
                {
                    subMatrix->setCurrentNameAndNum((*paramArg)[setPWDNAMatrix], 3, 
                                                     Protein, Pairwise);
                    pwDNAUserMatrixName = (*paramArg)[setPWDNAMatrix];
                }
                else 
                    exit(1);
            }
        }
    }

    //** ? /dnamatrix=ID (user's file)
    if(setDNAMatrix != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting dnamatrix parameter.");
            }        
        #endif 
        temp = (*paramArg)[setDNAMatrix].length();
        if(temp > 0) 
        {
            _matrixname = ConvertStringToLower((*paramArg)[setDNAMatrix]);

            if (_matrixname.compare("iub") == 0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 1, DNA, MultipleAlign);
            }
            else if (_matrixname.compare("clustalw") == 0) 
            {
                subMatrix->setCurrentNameAndNum(_matrixname, 2, DNA, MultipleAlign);
            }
            else 
            {
                char hackTempName[FILENAMELEN + 1];
                strcpy(hackTempName, (*paramArg)[setDNAMatrix].c_str());
                    
                if(subMatrix->getUserMatFromFile(hackTempName, DNA, MultipleAlign))
                {
                    subMatrix->setCurrentNameAndNum((*paramArg)[setDNAMatrix], 3, 
                                                     Protein, MultipleAlign);
                    DNAUserMatrixName = (*paramArg)[setDNAMatrix];
                }
                else 
                    exit(1);
            }
        }
    }
 
       
    //** ? /maxdiv= n
    if(setMaxDiv != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting maxdiv parameter.");
            }       
        #endif 
        temp = 0;
        if((*paramArg)[setMaxDiv].length() > 0)
        {
            if (sscanf((*paramArg)[setMaxDiv].c_str(),"%d",&temp)!=1) 
            {
                reportBadOptionAndExit("maxdiv", "integer");
                temp = 0;
            }
        }
        if (temp >= 0)
        {
            userParameters->setDivergenceCutoff(temp);
        }
    }

    //** ? /gapdist= n
    if(setGapDist != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting gapdist parameter.");
            }       
        #endif
         
        temp = 0;
        if((*paramArg)[setGapDist].length() > 0)
            if (sscanf((*paramArg)[setGapDist].c_str(),"%d",&temp)!=1) 
            {
                reportBadOptionAndExit("gapdist", "integer");
            }
        if (temp >= 0)
        {
            userParameters->setGapDist(temp);
        }
    }

    //** ? /debug= n 
    if(setDebug != -1) 
    {
        temp = 0;
        if((*paramArg)[setDebug].length() > 0)
            if (sscanf((*paramArg)[setDebug].c_str(),"%d",&temp)!=1) 
            {
                reportBadOptionAndExit("debug", "integer");
            }
        if (temp >= 0)
        {
            userParameters->setDebug(temp);
        }
    }

    //** ? /outfile= (user's file) 
    if(setOutfile != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting outfile parameter.");
            }        
        #endif
        if((*paramArg)[setOutfile].length() > 0) 
        {
            userParameters->setOutfileName((*paramArg)[setOutfile]);
        }
    }

    //*** ? /case= lower/upper 
    if(setCase != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting case parameter.");
            }       
        #endif 
        if((*paramArg)[setCase].length() > 0) 
        {
            temp = findMatch((*paramArg)[setCase], caseArg, 2);
            if(temp == 0) 
            {
                userParameters->setLowercase(true);
            }
            else if(temp == 1) 
            {
                userParameters->setLowercase(false);
            }
            else
            {
                cerr << "\nUnknown case " <<  (*paramArg)[setCase] << endl;
            }
        }
    }

    //*** ? /seqnos=off/on 
    if(setSeqNo != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting seqnos parameter.");
            }         
        #endif
        if((*paramArg)[setSeqNo].length() > 0) 
        {
            temp = findMatch((*paramArg)[setSeqNo], seqNoArg, 2);
            if(temp == 0) 
            {
                userParameters->setClSeqNumbers(false);
            }
            else if(temp == 1) 
            {
                userParameters->setClSeqNumbers(true);
            }
            else
            {
                cerr << "\nUnknown SEQNO option " << (*paramArg)[setSeqNo] << endl;
            }
        }
    }


    if(setSeqNoRange != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting seqno range parameter.");
            }        
        #endif
        if((*paramArg)[setSeqNoRange].length() > 0) 
        {
            temp = findMatch((*paramArg)[setSeqNoRange], seqNoRangeArg, 2);
            cout << "\n comparing  " 
                 << "\nparamArg[setSeqNoRange]= " << (*paramArg)[setSeqNoRange]
                 << "\n comparing \n "; 

            if(temp == 0) 
            {
                userParameters->setSeqRange(false);
            }
            else if(temp == 1) 
            {
                userParameters->setSeqRange(true);
            }
            else
            {
                cerr << "\nUnknown Sequence range  option " 
                     << (*paramArg)[setSeqNoRange] << endl;
            }
        }
    }

    //*** ? /range=n:m
    if(setRange != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting range parameter.");
            }        
        #endif
        temp = 0;
        if((*paramArg)[setRange].length() > 0)
        {
            // NOTE I have made a big change here! Mark march 14th 2006. This was being done
            // in the Alignment output functions. 
            int iFirstRes = -1; 
            int iLastRes = -1;
            char ignore;
            
            if (sscanf((*paramArg)[setRange].c_str(), "%d%[ :,-]%d", &iFirstRes,
                        &ignore, &iLastRes) != 3) 
            {
                cerr << "setRange:  Syntax Error: Cannot set range, should be from:to \n";
            }
            else
            {
                userParameters->setRangeFrom(iFirstRes);
                userParameters->setRangeTo(iLastRes);
            }
        }
    }

    //*** ? /gapopen=n 
    if(setGapOpen != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting gapopen parameter.");
            }        
        #endif
        ftemp = 0.0;
        if((*paramArg)[setGapOpen].length() > 0)
        {
            if (sscanf((*paramArg)[setGapOpen].c_str(),"%f",&ftemp) != 1) 
            {
                reportBadOptionAndExit("gapopen", "real number");
                ftemp = 0.0;
            }
            if(ftemp >= 0.0)
            {
                if( userParameters->getDNAFlag()) 
                {
                    userParameters->setGapOpen(ftemp);
                    userParameters->setDNAGapOpen(ftemp);
                }
                else 
                {
                    userParameters->setGapOpen(ftemp);
                    userParameters->setProteinGapOpen(ftemp);
                }
            }
        }
    }

    //*** ? /gapext=n
    if(setGapExtend != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting gap extention parameter.");
            }        
        #endif
        
        ftemp = 0.0;
        if((*paramArg)[setGapExtend].length() > 0)
        {
            if (sscanf((*paramArg)[setGapExtend].c_str(),"%f",&ftemp) != 1) 
            {
                reportBadOptionAndExit("gapext", "real number");
               ftemp = 0.0;
            }
            if(ftemp >= 0)
            {
                if(userParameters->getDNAFlag()) 
                {
                    userParameters->setGapExtend(ftemp);
                    userParameters->setDNAGapExtend(ftemp);
                }
                else 
                {
                    userParameters->setGapExtend(ftemp);
                    userParameters->setProteinGapExtend(ftemp);
                }
            }
        }
    }

    //*** ? /transweight=n
    if(setTransWeight != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting transweight parameter.");
            }        
        #endif
        
        ftemp = 0.0;
        if((*paramArg)[setTransWeight].length() > 0)
        {
            if (sscanf((*paramArg)[setTransWeight].c_str(), "%f", &ftemp) != 1) 
            {
                reportBadOptionAndExit("transweight", "real number");
            }
        }
        userParameters->setTransitionWeight(ftemp);
    }

    //*** ? /pwgapopen=n 
    if(setPWGapOpen != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting pwgapopen parameter.");
            }        
        #endif
        
        ftemp = 0.0;
        if((*paramArg)[setPWGapOpen].length() > 0)
        {
            if (sscanf((*paramArg)[setPWGapOpen].c_str(), "%f", &ftemp) != 1) 
            {
                reportBadOptionAndExit("pwgapopen", "real number");
            }
        }
        if(ftemp >= 0.0)
        {
            if(userParameters->getDNAFlag()) 
            {
                userParameters->setPWGapOpen(ftemp);
                userParameters->setDNAPWGapOpenPenalty(ftemp);
            }
            else 
            {
                userParameters->setPWGapOpen(ftemp);
                userParameters->setProteinPWGapOpenPenalty(ftemp);
            }
        }
    }


    //*** ? /gapext=n 
    if(setPWGapExtend != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting pwgapext parameter.");
            }        
        #endif
        
        ftemp = 0.0;
        if((*paramArg)[setPWGapExtend].length() > 0)
        {
            if (sscanf((*paramArg)[setPWGapExtend].c_str(), "%f", &ftemp) != 1) 
            {
                reportBadOptionAndExit("pwgapext", "real number");
            }
        }
        if(ftemp >= 0)
        {
            if(userParameters->getDNAFlag()) 
            {
                userParameters->setPWGapExtend(ftemp);
                userParameters->setDNAPWGapExtendPenalty(ftemp);
            }
            else 
            {
                userParameters->setPWGapExtend(ftemp);
                userParameters->setProteinPWGapExtendPenalty(ftemp);
            }
        }
    }



    //*** ? /outorder=n 
    if(setOutOrder != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting outorder parameter.");
            }        
        #endif
        
        if((*paramArg)[setOutOrder].length() > 0)
        {
            temp = findMatch((*paramArg)[setOutOrder],outOrderArg,2);
        }

        if(temp == 0) 
        {    
            userParameters->setOutputOrder(INPUT);
        }
        else if(temp == 1) 
        {    
            userParameters->setOutputOrder(ALIGNED);
        }
        else
        {
            cerr << "\nUnknown OUTPUT ORDER type " <<  (*paramArg)[setOutOrder] << endl;
        }
    }

    //*** ? /bootlabels=n 
    if(setBootLabels != -1) 
    {

        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting bootlabels parameter.");
            }        
        #endif
        
        if((*paramArg)[setBootLabels].length() > 0)
        {
            temp = findMatch((*paramArg)[setBootLabels], bootLabelsArg, 2);
        }

        if(temp == 0)  
        {    
            userParameters->setBootstrapFormat(BS_NODE_LABELS);
        }
        else if(temp == 1)  
        {    
            userParameters->setBootstrapFormat(BS_BRANCH_LABELS);
        }
        else
        {
            cerr << "\nUnknown bootlabels type " << (*paramArg)[setBootLabels] << endl;
        }
    }

    //*** ? /endgaps 
    if(setUseEndGaps != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting useendgaps=true");
            }        
        #endif
        
        userParameters->setUseEndGaps(false);
    }

    //*** ? /nopgap 
    if(setNoPGap != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting noPrefPenalties=true");
            }        
        #endif
        
        userParameters->setNoPrefPenalties(true);
    }

    //*** ? /nohgap 
    if(setNoHGap != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting nohgap=true");
            }        
        #endif
        
        userParameters->setNoHydPenalties(true);
    }

    //*** ? /novgap 
    if(setNoVGap != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting novgap=false");
            }        
        #endif
        
        userParameters->setNoVarPenalties(false);
    }

    //*** ? /hgapresidues="string" 
    // NOTE I have made some big changes here. It looks as if there was an error here!
    if(setHGapRes != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting hgapresidues parameter.");
            }        
        #endif
        
        userParameters->setHydResidues((*paramArg)[setHGapRes]);
        
    }
              
    //*** ? /nosecstr1 
    if(setSecStruct1 != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting useSS1=false");
            }        
        #endif
        
        userParameters->setUseSS1(false);
    }

    //*** ? /nosecstr2 
    if(setSecStruct2 != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting useSS2=false");
            }        
        #endif
        
        userParameters->setUseSS2(false);
    }

    //*** ? /secstroutput
    if(setSecStructOutput != -1)
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting secstroutput parameter.");
            }        
        #endif
        
        if((*paramArg)[setSecStructOutput].length() > 0) 
        {
            temp = findMatch((*paramArg)[setSecStructOutput], outputSecStrArg, 4);
            if(temp >= 0 && temp <= 3)
            {
                userParameters->setOutputStructPenalties(temp);
            }
            else
            {
                cerr << "\nUnknown case " << (*paramArg)[setSecStructOutput] << endl;
            }
        }
    }


    //*** ? /helixgap= n
    if(setHelixGap != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting helixgap parameter.");
            }        
        #endif
        
        temp = 0;
        if((*paramArg)[setHelixGap].length() > 0)
        {
            if (sscanf((*paramArg)[setHelixGap].c_str(), "%d", &temp) != 1) 
            {
                reportBadOptionAndExit("helixgap", "integer");
            }
        }
        if (temp >= 1 && temp <= 9)
        {
            userParameters->setHelixPenalty(temp);
        }
    }
    
    //*** ? /strandgap= n 
    if(setStrandGap != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting strandgap parameter.");
            }         
        #endif
        
        temp = 0;
        if((*paramArg)[setStrandGap].length() > 0)
        {
            if (sscanf((*paramArg)[setStrandGap].c_str(), "%d", &temp) != 1) 
            {
                reportBadOptionAndExit("strandgap", "integer");
            }
        }
        if (temp >= 1 && temp <= 9)
        {
            userParameters->setStrandPenalty(temp);
        }
    }
    
    //*** ? /loopgap= n 
    if(setLoopGap != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting loopgap parameter.");
            }        
        #endif
        
        temp = 0;
        if((*paramArg)[setLoopGap].length() > 0)
        {
            if (sscanf((*paramArg)[setLoopGap].c_str(), "%d", &temp) != 1) 
            {
                reportBadOptionAndExit("loopgap", "integer");
            }
        }
        if (temp >= 1 && temp <= 9)
        {
            userParameters->setLoopPenalty(temp);
        }
    }

    //*** ? /terminalgap= n
    if(setTerminalGap != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting terminalgap parameter.");
            }        
        #endif
        temp = 0;
        if((*paramArg)[setTerminalGap].length() > 0)
        {
            if (sscanf((*paramArg)[setTerminalGap].c_str(), "%d", &temp) != 1) 
            {
                reportBadOptionAndExit("terminalgap", "integer");
                temp = 0;
            }
        }
        if (temp >= 1 && temp <= 9) 
        {
            userParameters->setHelixEndPenalty(temp);
            userParameters->setStrandEndPenalty(temp);
        }
    }
   
    //*** ? /helixendin= n
    if(setHelixEndIn != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting helixendin parameter.");
            }        
        #endif
        
        temp = 0;
        if((*paramArg)[setHelixEndIn].length() > 0)
        {
            if (sscanf((*paramArg)[setHelixEndIn].c_str(), "%d", &temp) != 1) 
            {
                reportBadOptionAndExit("helixendin", "integer");
                temp = 0;
            }
        }
        if (temp >= 0 && temp <= 3)
        {
            userParameters->setHelixEndMinus(temp);
        }
    }

    //*** ? /helixendout= n
    if(setHelixEndOut != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting helixendout parameter.");
            }        
        #endif
        
        temp = 0;
        if((*paramArg)[setHelixEndOut].length() > 0)
        {
            if (sscanf((*paramArg)[setHelixEndOut].c_str(), "%d", &temp) != 1) 
            {
                reportBadOptionAndExit("helixendout", "integer");
                temp = 0;
            }
        }
        if (temp >= 0 && temp <= 3)
        {
            userParameters->setHelixEndPlus(temp);
        }
    }

    //*** ? /strandendin= n 
    if(setStrandEndIn != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting strandendin parameter.");
            }        
        #endif
        
        temp = 0;
        if((*paramArg)[setStrandEndIn].length() > 0)
        {
            if (sscanf((*paramArg)[setStrandEndIn].c_str(), "%d", &temp) != 1) 
            {
                reportBadOptionAndExit("strandendin", "integer");
            }
        }
        if (temp >= 0 && temp <= 3)
        {
            userParameters->setStrandEndMinus(temp);
        }
    }

    //*** ? /strandendout= n 
    if(setStrandEndOut != -1) 
    {
        #if DEBUGFULL 
            if(logObject && DEBUGLOG)
            {
                logObject->logMsg("    Setting strandendout parameter.");
            }        
        #endif
        
        temp = 0;
        if((*paramArg)[setStrandEndOut].length() > 0)
        {
            if (sscanf((*paramArg)[setStrandEndOut].c_str(), "%d", &temp) != 1) 
            {
                reportBadOptionAndExit("strandendout", "integer");
            }
        }
        if (temp >= 0 && temp <= 3)
        {
            userParameters->setStrandEndPlus(temp);
        }
    }
}

int CommandLineParser::findMatch(string probe, StringArray* list, int n)
{
    int i, j, len;
    int count, match=0;
  
    len = probe.length();
    for (i = 0; i < len; i++) 
    {
        count = 0;
        for (j = 0; j < n; j++) 
        { 
            if (probe[i] == (*list)[j][i]) 
            {
                match = j;
                count++;
            }
        }
        if (count == 0)
        { 
            return((int)-1);
        }
        if (count == 1) 
        {
            return(match);
        }
    }
    return((int)-1);

}

/*
 * The function getCmdLineDataStruct is used to return a struct with the values
 * specified. It returns it by value. I cant return by reference or else the object will
 * be destroyed.
 */
CmdLineData CommandLineParser::getCmdLineDataStruct(const char *str, int *flag, int type, 
                                                      StringArray* arg)
{
    CmdLineData tempStruct = {str, flag, type, arg};
    return tempStruct;
}

void CommandLineParser::printCmdLineData(const CmdLineData& temp)
{
    std::cout << "The str is: " << temp.str << std::endl;
    std::cout << "The int* is: " << *(temp.flag) << std::endl;
    std::cout << "The type is: " << temp.type << std::endl;
    std::cout << "The StringArray is: " << std::endl;
    
    if(temp.arg == NULL)
    {
        std::cout << "    NULL" << std::endl;
    }
    else
    {
        cout << "The number of elements is " << temp.arg->size() << std::endl;
        for(int i = 0; i < (int)temp.arg->size(); i++)
        {
            cout << "The " << i << "th element is: " << temp.arg->at(i) << endl;
        }
    }
}

/*
 * Helper function to change string to lower case.
 *
 */
string CommandLineParser::ConvertStringToLower(string strToConvert)
{
   for(unsigned int i=0;i<strToConvert.length();i++)
   {
      strToConvert[i] = tolower(strToConvert[i]);
   }
   return strToConvert;
}




void  CommandLineParser::exitWithErrorMsg(string msg)
{
    cerr << "ERROR: " << msg << std::endl;
    exit(1);
}

void CommandLineParser::reportBadOptionAndExit(string option, string expectedType)
{
    string msg;
    msg = "Bad option for ";
    msg += default_commandsep;// has to be added separately
    msg += option + ": expected " +  expectedType;
    exitWithErrorMsg(msg);
}

void CommandLineParser::reportInvalidOptionAndExit(string option)
{
    string msg = "Invalid option ";
    msg += default_commandsep;// has to be added separately
    msg += option;
    exitWithErrorMsg(msg);
}


}