- refactorized the whole project and made a few subprojects

- replaced tcp with enet
- added connect dialog
- some smaller bugfixes

1 files changed, 0 insertions, 1175 deletions

diff --git a/pacman-c++/anyoption.cpp b/pacman-c++/anyoption.cpp
deleted file mode 100644
index 4e3828e..0000000
--- a/pacman-c++/anyoption.cpp
+++ /dev/null
@@ -1,1175 +0,0 @@
-/*
- * AnyOption 1.3  
- *
- * kishan at hackorama dot com  www.hackorama.com JULY 2001 
- *
- * + Acts as a common facade class for reading 
- *   commandline options as well as options from
- *   an optionfile with delimited type value pairs 
- *
- * + Handles the POSIX style single character options ( -w )
- *   as well as the newer GNU long options ( --width )
- * 
- * + The option file assumes the traditional format of
- *   first character based comment lines and type value
- *   pairs with a delimiter , and flags which are not pairs
- * 
- *      # this is a coment
- *      # next line is an option value pair
- *      width : 100
- *      # next line is a flag 
- *      noimages   
- * 
- * + Supports printing out Help and Usage  
- * 
- * + Why not just use getopt() ? 
- *
- *   getopt() Its a POSIX standard not part of ANSI-C. 
- *   So it may not be available on platforms like Windows.
- *
- * + Why it is so long ?
- *
- *   The actual code which does command line parsing 
- *   and option file parsing are done in  few methods. 
- *   Most of the extra code are for providing a flexible
- *   common public interface to both a resourcefile and
- *   and command line supporting POSIX style and  
- *   GNU long option as well as mixing of both. 
- * 
- * + Please see "anyoption.h" for public method descriptions 
- *   
- */
-
-/* Updated Auguest 2004 
- * Fix from  Michael D Peters (mpeters at sandia.gov) 
- * to remove static local variables, allowing multiple instantiations 
- * of the reader (for using multiple configuration files).  There is
- * an error in the destructor when using multiple instances, so you
- * cannot delete your objects (it will crash), but not calling the 
- * destructor only introduces a small memory leak, so I
- * have not bothered tracking it down.
- *
- * Also updated to use modern C++ style headers, rather than
- * depricated iostream.h (it was causing my compiler problems)
-*/
-
-/* 
- * Updated September 2006  
- * Fix from Boyan Asenov for a bug in mixing up option indexes 
- * leading to exception when mixing different options types
- */
-
-#include "anyoption.h"
-#include <cstring>
-
-AnyOption::AnyOption()
-{
-        init();
-}
-
-AnyOption::AnyOption(int maxopt)
-{
-        init( maxopt , maxopt );
-}
-
-AnyOption::AnyOption(int maxopt, int maxcharopt)
-{
-        init( maxopt , maxcharopt );
-}
-
-AnyOption::~AnyOption()
-{
-        if( mem_allocated )
-                cleanup();
-}
-
-void
-AnyOption::init()
-{
-        init( DEFAULT_MAXOPTS , DEFAULT_MAXOPTS );
-}
-
-void
-AnyOption::init(int maxopt, int maxcharopt )
-{
-
-        max_options     = maxopt;
-        max_char_options = maxcharopt;
-        max_usage_lines = DEFAULT_MAXUSAGE;
-        usage_lines     = 0 ;
-        argc            = 0;
-        argv            = NULL;
-        posix_style     = true;
-        verbose         = false;
-        filename        = NULL;
-        appname         = NULL; 
-        option_counter  = 0;
-        optchar_counter = 0;
-        new_argv        = NULL;
-        new_argc        = 0 ;
-        max_legal_args  = 0 ;
-        command_set     = false;
-        file_set        = false;
-        values          = NULL; 
-        g_value_counter = 0;
-        mem_allocated   = false;
-        command_set     = false;
-        file_set        = false;
-        opt_prefix_char     = '-';
-        file_delimiter_char = ':';
-        file_comment_char   = '#';
-        equalsign       = '=';
-        comment       = '#' ;
-        delimiter     = ':' ;
-        endofline     = '\n';
-        whitespace    = ' ' ;
-        nullterminate = '\0';
-        set = false;
-        once = true;
-        hasoptions = false;
-        autousage = false;
-
-        strcpy( long_opt_prefix , "--" );
-
-        if( alloc() == false ){
-                cout << endl << "OPTIONS ERROR : Failed allocating memory" ;
-                cout << endl ;
-                cout << "Exiting." << endl ;
-                exit (0);
-        }
-}
-
-bool
-AnyOption::alloc()
-{
-        int i = 0 ;
-        int size = 0 ;
-
-        if( mem_allocated )
-                return true;
-
-        size = (max_options+1) * sizeof(const char*);
-        options = (const char**)malloc( size ); 
-        optiontype = (int*) malloc( (max_options+1)*sizeof(int) );      
-        optionindex = (int*) malloc( (max_options+1)*sizeof(int) );     
-        if( options == NULL || optiontype == NULL || optionindex == NULL )
-                return false;
-        else
-                mem_allocated  = true;
-        for( i = 0 ; i < max_options ; i++ ){
-                options[i] = NULL;
-                optiontype[i] = 0 ;
-                optionindex[i] = -1 ;
-        }
-        optionchars = (char*) malloc( (max_char_options+1)*sizeof(char) );
-        optchartype = (int*) malloc( (max_char_options+1)*sizeof(int) );        
-        optcharindex = (int*) malloc( (max_char_options+1)*sizeof(int) );       
-        if( optionchars == NULL || 
-            optchartype == NULL || 
-            optcharindex == NULL )
-        {
-                mem_allocated = false;
-                return false;
-        }
-        for( i = 0 ; i < max_char_options ; i++ ){
-                optionchars[i] = '0';
-                optchartype[i] = 0 ;
-                optcharindex[i] = -1 ;
-        }
-
-        size = (max_usage_lines+1) * sizeof(const char*) ;
-        usage = (const char**) malloc( size );
-
-        if( usage == NULL  ){
-                mem_allocated = false;
-                return false;
-        }
-        for( i = 0 ; i < max_usage_lines ; i++ )
-                usage[i] = NULL;
-
-        return true;
-}
-
-bool
-AnyOption::doubleOptStorage()
-{
-        options = (const char**)realloc( options,  
-                        ((2*max_options)+1) * sizeof( const char*) );
-        optiontype = (int*) realloc(  optiontype ,  
-                        ((2 * max_options)+1)* sizeof(int) );   
-        optionindex = (int*) realloc(  optionindex,  
-                        ((2 * max_options)+1) * sizeof(int) );  
-        if( options == NULL || optiontype == NULL || optionindex == NULL )
-                return false;
-        /* init new storage */
-        for( int i = max_options ; i < 2*max_options ; i++ ){
-                options[i] = NULL;
-                optiontype[i] = 0 ;
-                optionindex[i] = -1 ;
-        }
-        max_options = 2 * max_options ;
-        return true;
-}
-
-bool
-AnyOption::doubleCharStorage()
-{
-        optionchars = (char*) realloc( optionchars,  
-                        ((2*max_char_options)+1)*sizeof(char) );
-        optchartype = (int*) realloc( optchartype,  
-                        ((2*max_char_options)+1)*sizeof(int) ); 
-        optcharindex = (int*) realloc( optcharindex,  
-                        ((2*max_char_options)+1)*sizeof(int) ); 
-        if( optionchars == NULL || 
-            optchartype == NULL || 
-            optcharindex == NULL )
-                return false;
-        /* init new storage */
-        for( int i = max_char_options ; i < 2*max_char_options ; i++ ){
-                optionchars[i] = '0';
-                optchartype[i] = 0 ;
-                optcharindex[i] = -1 ;
-        }
-        max_char_options = 2 * max_char_options;        
-        return true;
-}
-
-bool
-AnyOption::doubleUsageStorage()
-{
-        usage = (const char**)realloc( usage,  
-                        ((2*max_usage_lines)+1) * sizeof( const char*) );
-        if ( usage == NULL )
-                return false;
-        for( int i = max_usage_lines ; i < 2*max_usage_lines ; i++ )
-                usage[i] = NULL;
-        max_usage_lines = 2 * max_usage_lines ;
-        return true;
-
-}
-
-
-void
-AnyOption::cleanup()
-{
-        free (options);
-        free (optiontype);
-        free (optionindex);     
-        free (optionchars);
-        free (optchartype);
-        free (optcharindex);
-        free (usage);
-        if( values != NULL )
-                free (values);
-        if( new_argv != NULL )
-                free (new_argv);
-}
-
-void
-AnyOption::setCommandPrefixChar( char _prefix )
-{
-        opt_prefix_char = _prefix;
-}
-
-void
-AnyOption::setCommandLongPrefix( char *_prefix )
-{
-        if( strlen( _prefix ) > MAX_LONG_PREFIX_LENGTH ){
-                *( _prefix + MAX_LONG_PREFIX_LENGTH ) = '\0'; 
-        }
-
-        strcpy (long_opt_prefix,  _prefix);
-}
-
-void
-AnyOption::setFileCommentChar( char _comment )
-{
-        file_delimiter_char = _comment;
-}
-
-
-void
-AnyOption::setFileDelimiterChar( char _delimiter )
-{
-        file_comment_char = _delimiter ;
-}
-
-bool
-AnyOption::CommandSet()
-{
-        return( command_set );
-}
-
-bool
-AnyOption::FileSet()
-{
-        return( file_set );
-}
-
-void
-AnyOption::noPOSIX()
-{
-        posix_style = false;
-}
-
-bool
-AnyOption::POSIX()
-{
-        return posix_style;
-}
-
-
-void
-AnyOption::setVerbose()
-{
-        verbose = true ;
-}
-
-void
-AnyOption::printVerbose()
-{
-        if( verbose )
-                cout << endl  ;
-}
-void
-AnyOption::printVerbose( const char *msg )
-{
-        if( verbose )
-                cout << msg  ;
-}
-
-void
-AnyOption::printVerbose( char *msg )
-{
-        if( verbose )
-                cout << msg  ;
-}
-
-void
-AnyOption::printVerbose( char ch )
-{
-        if( verbose )
-                cout << ch ;
-}
-
-bool
-AnyOption::hasOptions()
-{
-        return hasoptions;
-}
-
-void
-AnyOption::autoUsagePrint(bool _autousage)
-{
-        autousage = _autousage;
-}
-
-void
-AnyOption::useCommandArgs( int _argc, char **_argv )
-{
-        argc = _argc;
-        argv = _argv;
-        command_set = true;
-        appname = argv[0];
-        if(argc > 1) hasoptions = true;
-}
-
-void
-AnyOption::useFiileName( const char *_filename )
-{
-        filename = _filename;
-        file_set = true;
-}
-
-/*
- * set methods for options 
- */
-
-void
-AnyOption::setCommandOption( const char *opt )
-{
-        addOption( opt , COMMAND_OPT );
-        g_value_counter++;
-}
-
-void
-AnyOption::setCommandOption( char opt )
-{
-        addOption( opt , COMMAND_OPT );
-        g_value_counter++;
-}
-
-void
-AnyOption::setCommandOption( const char *opt , char optchar )
-{
-        addOption( opt , COMMAND_OPT );
-        addOption( optchar , COMMAND_OPT );
-        g_value_counter++;
-}
-
-void
-AnyOption::setCommandFlag( const char *opt )
-{
-        addOption( opt , COMMAND_FLAG );
-        g_value_counter++;
-}
-
-void
-AnyOption::setCommandFlag( char opt )
-{
-        addOption( opt , COMMAND_FLAG );
-        g_value_counter++;
-}
-
-void
-AnyOption::setCommandFlag( const char *opt , char optchar )
-{
-        addOption( opt , COMMAND_FLAG );
-        addOption( optchar , COMMAND_FLAG );
-        g_value_counter++;
-}
-
-void
-AnyOption::setFileOption( const char *opt )
-{
-        addOption( opt , FILE_OPT );
-        g_value_counter++;
-}
-
-void
-AnyOption::setFileOption( char opt )
-{
-        addOption( opt , FILE_OPT );
-        g_value_counter++;
-}
-
-void
-AnyOption::setFileOption( const char *opt , char optchar )
-{
-        addOption( opt , FILE_OPT );
-        addOption( optchar, FILE_OPT  );
-        g_value_counter++;
-}
-
-void
-AnyOption::setFileFlag( const char *opt )
-{
-        addOption( opt , FILE_FLAG );
-        g_value_counter++;
-}
-
-void
-AnyOption::setFileFlag( char opt )
-{
-        addOption( opt , FILE_FLAG );
-        g_value_counter++;
-}
-
-void
-AnyOption::setFileFlag( const char *opt , char optchar )
-{
-        addOption( opt , FILE_FLAG );
-        addOption( optchar , FILE_FLAG );
-        g_value_counter++;
-}
-
-void
-AnyOption::setOption( const char *opt )
-{
-        addOption( opt , COMMON_OPT );
-        g_value_counter++;
-}
-
-void
-AnyOption::setOption( char opt )
-{
-        addOption( opt , COMMON_OPT );
-        g_value_counter++;
-}
-
-void
-AnyOption::setOption( const char *opt , char optchar )
-{
-        addOption( opt , COMMON_OPT );
-        addOption( optchar , COMMON_OPT );
-        g_value_counter++;
-}
-
-void
-AnyOption::setFlag( const char *opt )
-{
-        addOption( opt , COMMON_FLAG );
-        g_value_counter++;
-}
-
-void
-AnyOption::setFlag( const char opt )
-{
-        addOption( opt , COMMON_FLAG );
-        g_value_counter++;
-}
-
-void
-AnyOption::setFlag( const char *opt , char optchar )
-{
-        addOption( opt , COMMON_FLAG );
-        addOption( optchar , COMMON_FLAG );
-        g_value_counter++;
-}
-
-void
-AnyOption::addOption( const char *opt, int type )
-{
-        if( option_counter >= max_options ){
-                if( doubleOptStorage() == false ){
-                        addOptionError( opt );
-                        return;
-                }
-        }
-        options[ option_counter ] = opt ;
-        optiontype[ option_counter ] =  type ;
-        optionindex[ option_counter ] = g_value_counter; 
-        option_counter++;
-}
-
-void
-AnyOption::addOption( char opt, int type )
-{
-        if( !POSIX() ){
-                printVerbose("Ignoring the option character \"");
-                printVerbose(  opt );
-                printVerbose( "\" ( POSIX options are turned off )" );
-                printVerbose();
-                return;
-        }
-
-
-        if( optchar_counter >= max_char_options ){
-                if( doubleCharStorage() == false ){
-                        addOptionError( opt );
-                        return;
-                }
-        }
-        optionchars[ optchar_counter ] =  opt ;
-        optchartype[ optchar_counter ] =  type ;
-        optcharindex[ optchar_counter ] = g_value_counter; 
-        optchar_counter++;
-}
-
-void
-AnyOption::addOptionError( const char *opt )
-{
-        cout << endl ;
-        cout << "OPTIONS ERROR : Failed allocating extra memory " << endl ;
-        cout << "While adding the option : \""<< opt << "\"" << endl;
-        cout << "Exiting." << endl ;
-        cout << endl ;
-        exit(0);
-}
-
-void
-AnyOption::addOptionError( char opt )
-{
-        cout << endl ;
-        cout << "OPTIONS ERROR : Failed allocating extra memory " << endl ;
-        cout << "While adding the option: \""<< opt << "\"" << endl;
-        cout << "Exiting." << endl ;
-        cout << endl ;
-        exit(0);
-}
-
-void
-AnyOption::processOptions()
-{
-        if( ! valueStoreOK() )
-                return;
-}
-
-void 
-AnyOption::processCommandArgs(int max_args)
-{
-        max_legal_args = max_args;
-        processCommandArgs();
-}
- 
-void
-AnyOption::processCommandArgs( int _argc, char **_argv, int max_args )
-{
-        max_legal_args = max_args;
-        processCommandArgs(  _argc, _argv );
-}
-
-void
-AnyOption::processCommandArgs( int _argc, char **_argv )
-{
-        useCommandArgs( _argc, _argv );
-        processCommandArgs();
-}
-
-void
-AnyOption::processCommandArgs()
-{
-        if( ! ( valueStoreOK() && CommandSet() )  )
-           return;
-           
-        if( max_legal_args == 0 )
-                max_legal_args = argc;
-        new_argv = (int*) malloc( (max_legal_args+1) * sizeof(int) );
-        for( int i = 1 ; i < argc ; i++ ){/* ignore first argv */
-                if(  argv[i][0] == long_opt_prefix[0] && 
-                     argv[i][1] == long_opt_prefix[1] ) { /* long GNU option */
-                        int match_at = parseGNU( argv[i]+2 ); /* skip -- */
-                        if( match_at >= 0 && i < argc-1 ) /* found match */
-                                setValue( options[match_at] , argv[++i] );
-                }else if(  argv[i][0] ==  opt_prefix_char ) { /* POSIX char */
-                        if( POSIX() ){ 
-                                char ch =  parsePOSIX( argv[i]+1 );/* skip - */ 
-                                if( ch != '0' && i < argc-1 ) /* matching char */
-                                        setValue( ch ,  argv[++i] );
-                        } else { /* treat it as GNU option with a - */
-                                int match_at = parseGNU( argv[i]+1 ); /* skip - */
-                                if( match_at >= 0 && i < argc-1 ) /* found match */
-                                        setValue( options[match_at] , argv[++i] );
-                        }
-                }else { /* not option but an argument keep index */
-                        if( new_argc < max_legal_args ){
-                                new_argv[ new_argc ] = i ;
-                                new_argc++;
-                        }else{ /* ignore extra arguments */
-                                printVerbose( "Ignoring extra argument: " );
-                                printVerbose( argv[i] );
-                                printVerbose( );
-                                printAutoUsage();
-                        }
-                        printVerbose( "Unknown command argument option : " );
-                        printVerbose( argv[i] );
-                        printVerbose( );
-                        printAutoUsage();
-                }
-        }
-}
-
-char 
-AnyOption::parsePOSIX( char* arg )
-{
-
-        for( unsigned int i = 0 ; i < strlen(arg) ; i++ ){ 
-                char ch = arg[i] ;
-                if( matchChar(ch) ) { /* keep matching flags till an option */
-                        /*if last char argv[++i] is the value */
-                        if( i == strlen(arg)-1 ){ 
-                                return ch;
-                        }else{/* else the rest of arg is the value */
-                                i++; /* skip any '=' and ' ' */
-                                while( arg[i] == whitespace 
-                                        || arg[i] == equalsign )
-                                        i++;    
-                                setValue( ch , arg+i );
-                                return '0';
-                        }
-                }
-        }
-        printVerbose( "Unknown command argument option : " );
-        printVerbose( arg );
-        printVerbose( );
-        printAutoUsage();
-        return '0';
-}
-
-int
-AnyOption::parseGNU( char *arg )
-{
-        int split_at = 0;
-        /* if has a '=' sign get value */
-        for( unsigned int i = 0 ; i < strlen(arg) ; i++ ){
-                if(arg[i] ==  equalsign ){
-                        split_at = i ; /* store index */
-                        i = strlen(arg); /* get out of loop */
-                }
-        }
-        if( split_at > 0 ){ /* it is an option value pair */
-                char* tmp = (char*) malloc(  (split_at+1)*sizeof(char) );
-                for( int i = 0 ; i < split_at ; i++ )
-                        tmp[i] = arg[i];
-                tmp[split_at] = '\0';
-
-                if ( matchOpt( tmp ) >= 0 ){
-                        setValue( options[matchOpt(tmp)] , arg+split_at+1 );
-                        free (tmp);
-                }else{
-                        printVerbose( "Unknown command argument option : " );
-                        printVerbose( arg );
-                        printVerbose( );
-                        printAutoUsage();
-                        free (tmp);
-                        return -1;
-                }
-        }else{ /* regular options with no '=' sign  */
-                return  matchOpt(arg);
-        }
-        return -1;
-}
-
-
-int 
-AnyOption::matchOpt( char *opt )
-{
-        for( int i = 0 ; i < option_counter ; i++ ){
-                if( strcmp( options[i], opt ) == 0 ){
-                        if( optiontype[i] ==  COMMON_OPT ||
-                            optiontype[i] ==  COMMAND_OPT )     
-                        { /* found option return index */
-                                return i;
-                        }else if( optiontype[i] == COMMON_FLAG ||
-                               optiontype[i] == COMMAND_FLAG )
-                        { /* found flag, set it */ 
-                                setFlagOn( opt );
-                                return -1;
-                        }
-                }
-        }
-        printVerbose( "Unknown command argument option : " );
-        printVerbose( opt  ) ;
-        printVerbose( );
-        printAutoUsage();
-        return  -1;     
-}
-bool
-AnyOption::matchChar( char c )
-{
-        for( int i = 0 ; i < optchar_counter ; i++ ){
-                if( optionchars[i] == c ) { /* found match */
-                        if(optchartype[i] == COMMON_OPT ||
-                             optchartype[i] == COMMAND_OPT )
-                        { /* an option store and stop scanning */
-                                return true;    
-                        }else if( optchartype[i] == COMMON_FLAG || 
-                                  optchartype[i] == COMMAND_FLAG ) { /* a flag store and keep scanning */
-                                setFlagOn( c );
-                                return true;
-                        }
-                }
-        }
-        //printVerbose( "Unknown command argument option : " );
-        //printVerbose( c ) ;
-        //printVerbose( );
-        printAutoUsage();
-        return false;
-}
-
-bool
-AnyOption::valueStoreOK( )
-{
-        int size= 0;
-        if( !set ){
-                if( g_value_counter > 0 ){
-                        size = g_value_counter * sizeof(char*);
-                        values = (char**)malloc( size );        
-                        for( int i = 0 ; i < g_value_counter ; i++)
-                                values[i] = NULL;
-                        set = true;
-                }
-        }
-        return  set;
-}
-
-/*
- * public get methods 
- */
-char*
-AnyOption::getValue( const char *option )
-{
-        if( !valueStoreOK() )
-                return NULL;
-
-        for( int i = 0 ; i < option_counter ; i++ ){
-                if( strcmp( options[i], option ) == 0 )
-                        return values[ optionindex[i] ];
-        }
-        return NULL;
-}
-
-bool
-AnyOption::getFlag( const char *option )
-{
-        if( !valueStoreOK() )
-                return false;
-        for( int i = 0 ; i < option_counter ; i++ ){
-                if( strcmp( options[i], option ) == 0 )
-                        return findFlag( values[ optionindex[i] ] );
-        }
-        return false;
-}
-
-char*
-AnyOption::getValue( char option )
-{
-        if( !valueStoreOK() )
-                return NULL;
-        for( int i = 0 ; i < optchar_counter ; i++ ){
-                if( optionchars[i] == option )
-                        return values[ optcharindex[i] ];
-        }
-        return NULL;
-}
-
-bool
-AnyOption::getFlag( char option )
-{
-        if( !valueStoreOK() )
-                return false;
-        for( int i = 0 ; i < optchar_counter ; i++ ){
-                if( optionchars[i] == option )
-                        return findFlag( values[ optcharindex[i] ] ) ;
-        }
-        return false;
-}
-
-bool
-AnyOption::findFlag( char* val )
-{
-        if( val == NULL )
-                return false;
-
-        if( strcmp( TRUE_FLAG , val ) == 0 )
-                return true;
-
-        return false;
-}
-
-/*
- * private set methods 
- */
-bool
-AnyOption::setValue( const char *option , char *value )
-{
-        if( !valueStoreOK() )
-                return false;
-        for( int i = 0 ; i < option_counter ; i++ ){
-                if( strcmp( options[i], option ) == 0 ){
-                        values[ optionindex[i] ] = (char*) malloc((strlen(value)+1)*sizeof(char));
-                        strcpy( values[ optionindex[i] ], value );
-                        return true;
-                }
-        }
-        return false;
-}
-
-bool
-AnyOption::setFlagOn( const char *option )
-{
-        if( !valueStoreOK() )
-                return false;
-        for( int i = 0 ; i < option_counter ; i++ ){
-                if( strcmp( options[i], option ) == 0 ){
-                        values[ optionindex[i] ] = (char*) malloc((strlen(TRUE_FLAG)+1)*sizeof(char));
-                        strcpy( values[ optionindex[i] ]  ,  TRUE_FLAG );
-                        return true;
-                }
-        }
-        return false;
-}
-
-bool
-AnyOption::setValue( char option , char *value )
-{
-        if( !valueStoreOK() )
-                return false;
-        for( int i = 0 ; i < optchar_counter ; i++ ){
-                if( optionchars[i] == option ){
-                        values[ optcharindex[i] ] = (char*) malloc((strlen(value)+1)*sizeof(char));
-                        strcpy( values[ optcharindex[i] ],  value );
-                        return true;
-                }
-        }
-        return false;
-}
-
-bool
-AnyOption::setFlagOn( char option )
-{
-        if( !valueStoreOK() )
-                return false;
-        for( int i = 0 ; i < optchar_counter ; i++ ){
-                if( optionchars[i] == option ){
-                        values[ optcharindex[i] ] = (char*) malloc((strlen(TRUE_FLAG)+1)*sizeof(char));
-                        strcpy( values[ optcharindex[i] ] , TRUE_FLAG );
-                        return true;
-                }
-        }
-        return false;
-}
-
-
-int
-AnyOption::getArgc( )
-{
-        return new_argc;
-}
-
-char* 
-AnyOption::getArgv( int index )
-{
-        if( index < new_argc ){
-                return ( argv[ new_argv[ index ] ] );
-        }
-        return NULL;
-}
-
-/* dotfile sub routines */
-
-bool
-AnyOption::processFile()
-{
-        if( ! (valueStoreOK() && FileSet())  )
-                return false;
-        return  ( consumeFile(readFile()) );
-}
-
-bool
-AnyOption::processFile( const char *filename )
-{
-        useFiileName(filename );
-        return ( processFile() );
-}
-
-char*
-AnyOption::readFile()
-{
-        return ( readFile(filename) );
-}
-
-/*
- * read the file contents to a character buffer 
- */
-
-char*
-AnyOption::readFile( const char* fname )
-{
-        int length;
-        char *buffer;
-        ifstream is;
-        is.open ( fname , ifstream::in );
-        if( ! is.good() ){
-                is.close();
-                return NULL;
-        }
-        is.seekg (0, ios::end);
-        length = is.tellg();
-        is.seekg (0, ios::beg);
-        buffer = (char*) malloc(length*sizeof(char));
-        is.read (buffer,length);
-        is.close();
-        return buffer;
-}
-
-/*
- * scans a char* buffer for lines that does not 
- * start with the specified comment character.
- */
-bool
-AnyOption::consumeFile( char *buffer )
-{
-
-        if( buffer == NULL ) 
-                return false;
-
-        char *cursor = buffer;/* preserve the ptr */
-        char *pline = NULL ;
-        int linelength = 0;
-        bool newline = true;
-        for( unsigned int i = 0 ; i < strlen( buffer ) ; i++ ){
-        if( *cursor == endofline ) { /* end of line */
-                if( pline != NULL ) /* valid line */
-                        processLine( pline, linelength );
-                        pline = NULL;
-                        newline = true;
-                }else if( newline ){ /* start of line */
-                        newline = false;
-                        if( (*cursor != comment ) ){ /* not a comment */
-                                pline = cursor ;
-                                linelength = 0 ;
-                        }
-                }
-                cursor++; /* keep moving */
-                linelength++;
-        }
-        free (buffer);
-        return true;
-}
-
-
-/*
- *  find a valid type value pair separated by a delimiter 
- *  character and pass it to valuePairs()
- *  any line which is not valid will be considered a value
- *  and will get passed on to justValue()
- *
- *  assuming delimiter is ':' the behaviour will be,
- *
- *  width:10    - valid pair valuePairs( width, 10 );
- *  width : 10  - valid pair valuepairs( width, 10 );
- *
- *  ::::        - not valid 
- *  width       - not valid
- *  :10         - not valid 
- *  width:      - not valid  
- *  ::          - not valid 
- *  :           - not valid 
- *  
- */
-
-void
-AnyOption::processLine( char *theline, int length  )
-{
-        bool found = false;
-        char *pline = (char*) malloc( (length+1)*sizeof(char) );
-        for( int i = 0 ; i < length ; i ++ )
-                pline[i]= *(theline++);
-        pline[length] = nullterminate;
-        char *cursor = pline ; /* preserve the ptr */
-        if( *cursor == delimiter || *(cursor+length-1) == delimiter ){
-                justValue( pline );/* line with start/end delimiter */
-        }else{
-                for( int i = 1 ; i < length-1 && !found ; i++){/* delimiter */
-                        if( *cursor == delimiter ){
-                                *(cursor-1) = nullterminate; /* two strings */
-                                found = true;
-                                valuePairs( pline , cursor+1 );
-                        }
-                        cursor++;
-                }
-                cursor++;
-                if( !found ) /* not a pair */
-                        justValue( pline );
-        }
-        free (pline);
-}
-
-/*
- * removes trailing and preceeding whitespaces from a string
- */
-char*
-AnyOption::chomp( char *str )
-{
-        while( *str == whitespace )
-                str++;
-        char *end = str+strlen(str)-1;
-        while( *end == whitespace )
-                end--;
-        *(end+1) = nullterminate;
-        return str;
-}
-
-void
-AnyOption::valuePairs( char *type, char *value )
-{
-        if ( strlen(chomp(type)) == 1  ){ /* this is a char option */
-                for( int i = 0 ; i < optchar_counter ; i++ ){
-                        if(  optionchars[i] == type[0]  ){ /* match */
-                                if( optchartype[i] == COMMON_OPT ||
-                                    optchartype[i] == FILE_OPT )
-                                {
-                                        setValue( type[0] , chomp(value) );
-                                        return;
-                                }
-                        }
-                }
-        }       
-        /* if no char options matched */
-        for( int i = 0 ; i < option_counter ; i++ ){
-                if( strcmp( options[i], type ) == 0 ){ /* match */
-                        if( optiontype[i] == COMMON_OPT ||
-                            optiontype[i] == FILE_OPT )
-                        {
-                                setValue( type , chomp(value) );
-                                return;
-                        }
-                }
-        }
-        printVerbose( "Unknown option in resourcefile : " );
-        printVerbose( type );
-        printVerbose( );
-}
-
-void
-AnyOption::justValue( char *type )
-{
-
-        if ( strlen(chomp(type)) == 1  ){ /* this is a char option */
-                for( int i = 0 ; i < optchar_counter ; i++ ){
-                        if(  optionchars[i] == type[0]  ){ /* match */
-                                if( optchartype[i] == COMMON_FLAG ||
-                                    optchartype[i] == FILE_FLAG )
-                                {
-                                        setFlagOn( type[0] );
-                                        return;
-                                }
-                        }
-                }
-        }       
-        /* if no char options matched */
-        for( int i = 0 ; i < option_counter ; i++ ){
-                if( strcmp( options[i], type ) == 0 ){ /* match */
-                        if( optiontype[i] == COMMON_FLAG ||
-                            optiontype[i] == FILE_FLAG )
-                        {
-                                setFlagOn( type );
-                                return;
-                        }
-                }
-        }
-        printVerbose( "Unknown option in resourcefile : " );
-        printVerbose( type  );
-        printVerbose( );
-}
-
-/*
- * usage and help 
- */
-
-
-void
-AnyOption::printAutoUsage()
-{
-        if( autousage ) printUsage();
-}
-
-void
-AnyOption::printUsage()
-{
-        
-        if( once ) {
-                once = false ;
-                cout << endl ;
-                for( int i = 0 ; i < usage_lines ; i++ )
-                        cout << usage[i] << endl ;      
-                cout << endl ;
-        }
-}
-        
-        
-void
-AnyOption::addUsage( const char *line )
-{
-        if( usage_lines >= max_usage_lines ){
-                if( doubleUsageStorage() == false ){
-                        addUsageError( line );
-                        exit(1);
-                }
-        }
-        usage[ usage_lines ] = line ;   
-        usage_lines++;
-}
-
-void
-AnyOption::addUsageError( const char *line )
-{
-        cout << endl ;
-        cout << "OPTIONS ERROR : Failed allocating extra memory " << endl ;
-        cout << "While adding the usage/help  : \""<< line << "\"" << endl;
-        cout << "Exiting." << endl ;
-        cout << endl ;
-        exit(0);
-
-}