readArgs.cpp

Go to the documentation of this file.

#include "options.hpp"

// Read command line args into their appropriate vars
bool ConfigOpts::argsRead( int argCount, char **argVar )
{
    // Create an error flag and set to false
    bool errorFlag = 0;
    // Create an error argument holder
    string errorArg = "";
    // Create a pointer to a bool array to work with arguments
    bool *p_hyph = new bool[ argCount ];
    // Create a pointer to a string array to work with arguments
    string *p_args = new string[ argCount ];

    // Skip the first argument - program name.
    for( int i = 1; i <= argCount; i++ )
    {
        // Store each argument into an array
        p_args[i-1] = argVar[i];
    }

    // Check each argument for a hyphen
    for( int i = 0; i < argCount; i++ )
    {
        // If the argument starts with '-'
        if( p_args[i][0] == '-' )
        {
            // Set the flag array element to true
            p_hyph[i] = 1;
        }
        // If the argument doesn't start with '-'
        else
        {
            // Set the flag array element to false
            p_hyph[i] = 0;
        }
    }

    // Check each of the flagged items
    for( int i = 0; i < argCount && errorFlag == 0; i++ )
    {
        // If the first char is a hyphen, and there is no error
        if( p_hyph[i] == 1 && errorFlag == 0 )
        {
            // Go through and check for valid flags and set the vars
            for( unsigned int j = 1; j < p_args[i].length() && errorFlag == 0; j++ )
            {
                // User flag switch
                switch( p_args[i][j] ) {
                    case 'R':
                        // Recurse directories
                        setFlags( Recurse_flag );
                        break;
                    case 'D':
                        // Season folder is double digits
                        setFlags( SeasonDigit_flag );
                        break;
                    case 'B':
                        // Blacklist location
                        if( i+1 <= argCount-1 )
                        {
                            setOptions( BlackListLocation_opt, p_args[i+1] );
                        }
                        break;
                    case 'S':
                        // Showlist location
                        if( i+1 <= argCount-1 )
                        {
                            setOptions( ShowListLocation_opt, p_args[i+1] );
                        }
                        break;
                    case 'i':
                        // Input directory or file
                        if( i+1 <= argCount-1 )
                        {
                            setOptions( InputSourceArgument_opt, p_args[i+1] );
                            setFlags( Input_flag );
                        }
                        break;
                    case 'o':
                        // Output directory
                        if( i+1 <= argCount-1 )
                        {
                            setOptions( OutputSourceArgument_opt, p_args[i+1] );
                            setFlags( Output_flag );
                        }
                        break;
                    case 'e':
                        // Perform the execution internally
                        setFlags( ExecuteInternally_flag );
                        break;
                    case 't':
                        // Do not execute - output to stdout
                        setFlags( TestActions_flag );
                        break;
                    case 'b':
                        // Write a script for execution
                        if( i+1 <= argCount-1 )
                        {
                            setOptions( ScriptFileLocation_opt, p_args[i+1] );
                            setFlags( WriteToScriptFile_flag );
                        }
                        break;
                    case 'r':
                        // Rename the input files
                        setFlags( RenameInputFiles_flag );
                        break;
                    case 'm':
                        // Move the input files
                        setFlags( MoveInputFiles_flag );
                        break;
                    case 'c':
                        // Copy the input files
                        setFlags( CopyInputFiles_flag );
                        break;
                    case 'q':
                        // Output nothing
                        setFlags( VerbosityLevelQuiet_flag );
                        break;
                    case 's':
                        // Output summary information
                        setFlags( VerbosityLevelSummary_flag );
                        break;
                    case 'v':
                        // Output summary and error information
                        setFlags( VerbosityLevelVerbose_flag );
                        break;
                    case 'l':
                        // Log file name and location
                        if( i+1 <= argCount-1 )
                        {
                            setOptions( LogFileLocation_opt, p_args[i+1] );
                            setFlags( WriteToLogFile_flag );
                        }
                        break;
                    case 'x':
                        // XML file name and location
                        if( i+1 <= argCount-1 )
                        {
                            setOptions( XmlFileLocation_opt, p_args[i+1] );
                            setFlags( WriteToXmlFile_flag );
                        }
                        break;
                    case 'g':
                        // Gap file name and location
                        if( i+1 <= argCount-1 )
                        {
                            setOptions( GapFileLocation_opt, p_args[i+1] );
                            setFlags( WriteToGapFile_flag );
                        }
                        break;
                    default:
                        // Set the error flag to true
                        errorFlag = 1;
                        // Store the unmatched argument
                        errorArg = p_args[i][j];
                }//end switch
            }//end for
        }//end if
    } //end for

    // Check command line args
    errorFlag = argsCheck( errorFlag, errorArg );

    // Clean up
    delete [] p_hyph;
    delete [] p_args;

    // Return 0 = success
    return errorFlag;
}

// Read command line args into their appropriate vars
bool ConfigOpts::argsCheck( int errorFlag, string errorArg )
{
    // If the error flag is true
    if( errorFlag == 1 )
    {
        // Print the argument that caused the error
        cout << "Incorrect argument: -" << errorArg << endl
             << "run 'clerk -h' for more information" << endl;
    }
    // If config file not found flag is true
    else if( getFlags( ConfigFileNotFound_flag ) == 1 && getFlags( RewriteDefaultFiles_flag ) == 0 )
    {
        // Print how to create files
        cout << "run 'clerk -F <DIR>' to create clerk.conf" << endl
             << "in one of the above directories" << endl;
    }
    // If the error flag is set to false
    if( errorFlag == 0 )
    {
        // Place the input directory/file into a temporary holder
        string inputArg = getOptions( InputSourceArgument_opt );
        // Check for trailing slashes on the input argument
        while( inputArg[inputArg.length()-1] == SLASH[0] )
        {
            // Remove the last character
            inputArg.erase( inputArg.length()-1, 1 );
        }
        // Save the input directory/file
        setOptions( InputSourceArgument_opt, inputArg );
        // Place the output directory into a temporary holder
        string outputArg = getOptions( OutputSourceArgument_opt );
        // Check for trailing slashes on the output argument
        while( outputArg[outputArg.length()-1] == SLASH[0] )
        {
            // Remove the last character
            outputArg.erase( outputArg.length()-1, 1 );
        }
        // Save the output directory
        setOptions( OutputSourceArgument_opt, outputArg );
    }

    // Return 1 = failure
    return errorFlag;
}