cleaned up options

src/options.cpp

 #include "options.hpp"
 
+Options::Options( int argc, char** argv ) {
+    validArguments.push_back( Argument( "bordersize",   'b', false ) );
+    validArguments.push_back( Argument( "padding",      'p', false ) );
+    validArguments.push_back( Argument( "color",        'c', false ) );
+    validArguments.push_back( Argument( "shader",       'r', false ) );
+    validArguments.push_back( Argument( "highlight",    'h', true ) );
+    validArguments.push_back( Argument( "format",       'f', false ) );
+    validArguments.push_back( Argument( "tolerance",    't', false ) );
+    validArguments.push_back( Argument( "nodecorations", 'n', false ) );
+    validArguments.push_back( Argument( "nokeyboard",   'k', true ) );
+    validArguments.push_back( Argument( "help",         'h', true ) );
+    validArguments.push_back( Argument( "xdisplay",     'x', false ) );
+    validArguments.push_back( Argument( "version",      'v', true ) );
+    validArguments.push_back( Argument( "quiet",        'q', true ) );
+    validate( argc, argv );
+}
+
+
 int Options::validateStringOption( int argc, char** argv, int argumentIndex ) {
     std::string argument = argv[argumentIndex];
     unsigned int index = 0;
-    while( index < validArgumentCount ) {
-        std::string& check = validStringArguments[index];
-        for( unsigned int i=0;i<check.length();i++ ) {
-            if ( check[i] != argument[i+2] ) {
+    while( index < validArguments.size() ) {
+        Argument& check = validArguments[index];
+        for( unsigned int i=0;i<check.name.length();i++ ) {
+            if ( check.name[i] != argument[i+2] ) {
                 break;
             }
-            if ( i == check.length()-1 ) {
-                if ( !isFlagArgument[index] && argument.find("=") == std::string::npos ) {
+            if ( i == check.name.length()-1 ) {
+                if ( !check.isFlagArgument && argument.find("=") == std::string::npos ) {
                     throw new std::invalid_argument("Expected `=` after " + arguments[i]);
                 }
-                if ( isFlagArgument[index] && i+3 != argument.length() ) {
+                if ( check.isFlagArgument && i+3 != argument.length() ) {
                     throw new std::invalid_argument("Trailing characters on flag " + argument );
                 }
                 return parseStringOption( argc, argv, argumentIndex, index );
 
 int Options::parseCharOption( int argc, char** argv, int argumentIndex, int validIndex ) {
     std::string argument = argv[argumentIndex];
+    Argument& check = validArguments[validIndex];
     // If we're a flag, we take no arguments, nor do we allow = signs or whatever.
-    if ( isFlagArgument[validIndex] ) {
-        if ( argument != std::string()+"-"+validCharArguments[validIndex] ) {
+    if ( check.isFlagArgument ) {
+        if ( argument != std::string()+"-"+check.cname ) {
             for( int o=1;o<argument.length();o++ ) {
                 bool isValid = false;
-                for( int i=0;i<validArgumentCount&&!isValid;i++ ) {
-                    if ( argument[o] == validCharArguments[i] ) {
-                        if ( isFlagArgument[i] ) {
+                for( int i=0;i<validArguments.size()&&!isValid;i++ ) {
+                    if ( argument[o] == check.cname ) {
+                        if ( check.isFlagArgument ) {
                             isValid = true;
-                            arguments.push_back( std::string()+validCharArguments[i] );
+                            arguments.push_back( std::string()+check.cname );
                             values.push_back("");
                             break;
                         } else {
     }
     arguments.push_back( std::string()+argument[1] );
     // If they supplied the parameters with spaces
-    if ( argument == std::string()+"-"+validCharArguments[validIndex] ) {
+    if ( argument == std::string()+"-"+check.cname ) {
         values.push_back(argv[argumentIndex+1]);
         return 2;
     }
 
 int Options::parseStringOption( int argc, char** argv, int argumentIndex, int validIndex ) {
     std::string argument = argv[argumentIndex];
-    if ( isFlagArgument[validIndex] ) {
+    if ( validArguments[validIndex].isFlagArgument ) {
         arguments.push_back( argument.substr(2) );
         values.push_back("");
         return 1;
 int Options::validateCharOption( int argc, char** argv, int argumentIndex ) {
     std::string argument = argv[argumentIndex];
     unsigned int index = 0;
-    while( index < validArgumentCount ) {
-        char check = validCharArguments[index];
+    while( index < validArguments.size() ) {
+        char check = validArguments[index].cname;
         if ( argument.length() < 2 ) {
             continue;
         }
             if ( floatingValues.size() > maxFloatingValues ) {
                 throw new std::invalid_argument("Unexpected floating value `" + argument + "`. Forget to specify an option?" );
             }
+            i++;
+            continue;
         }
         if ( argument[0] == '-' && argument[1] == '-' ) {
             i += validateStringOption( argc, argv, i );
     }
 }
 
-Options::Options( int argc, char** argv ) {
-    validate( argc, argv );
-}
-
 bool Options::getFloat( std::string name, char namec, float& found ) {
     for( unsigned int i=0;i<arguments.size();i++ ) {
         if ( arguments[i] == name || arguments[i] == std::string("")+namec ) {

src/options.hpp

 #include <vector>
 #include <glm/glm.hpp>
 
-static std::string validStringArguments[] = { "bordersize", "padding", "color", "shader", "highlight", "format", "tolerance", "nodecorations", "nokeyboard", "help", "xdisplay", "version", "quiet" };
-static char validCharArguments[] = { 'b', 'p', 'c', 'r', 'l', 'f', 't', 'n', 'k', 'h', 'x', 'v', 'q' };
-static unsigned int isFlagArgument[] = { false, false, false, false, true, false, false, false, true, true, false, true, true };
-static unsigned int validArgumentCount = 13;
+class Argument {
+public:
+    std::string name;
+    char cname;
+    bool isFlagArgument;
+    Argument( std::string name, char cname, bool isFlagArgument ) : name(name), cname(cname), isFlagArgument(isFlagArgument) {}
+};
+
+static std::vector<Argument> validArguments;
 static unsigned int maxFloatingValues = 0;
 
 class Options {