source: libcfa/src/parseconfig.cfa @ dcf792a

#include <fstream.hfa>
#include <parseargs.hfa>
#include <stdlib.hfa>
#include <string.h>
#include "parseconfig.hfa"


// *********************************** exceptions ***********************************


static vtable(Missing_Config_Entries) Missing_Config_Entries_vt;

void ?{}( Missing_Config_Entries & this, unsigned int num_missing ) {
        this.virtual_table = &Missing_Config_Entries_vt;
        this.num_missing = num_missing;
}


static vtable(Parse_Failure) Parse_Failure_vt;

void ?{}( Parse_Failure & this, char * failed_key, char * failed_value ) {
        this.virtual_table = &Parse_Failure_vt;

        this.failed_key = alloc( strlen( failed_key ) );
        this.failed_value = alloc( strlen( failed_value ) );
        strcpy( this.failed_key, failed_key );
        strcpy( this.failed_value, failed_value );
}

void ^?{}( Parse_Failure & this ) with ( this ) {
        free( failed_key );
        free( failed_value );
}


static vtable(Validation_Failure) Validation_Failure_vt;

void ?{}( Validation_Failure & this, char * failed_key, char * failed_value ) {
        this.virtual_table = &Validation_Failure_vt;

        this.failed_key = alloc( strlen( failed_key ) );
        this.failed_value = alloc( strlen( failed_value ) );
        strcpy( this.failed_key, failed_key );
        strcpy( this.failed_value, failed_value );
}

void ^?{}( Validation_Failure & this ) with ( this ) {
        free( failed_key );
        free( failed_value );
}
}


// *********************************** main code ***********************************


struct KVPairs {
        size_t size, max_size;
        * [ char *, char * ] data;
};

void ?{}( KVPairs & kvp ) with ( kvp ) {                                // default constructor
        size = 0; max_size = 0; data = 0p;
}

void ?{}( KVPairs & kvp, size_t size ) {                                // initialization
        kvp.[ size, max_size ] = [ 0, size ];
        kvp.data = alloc( size );
}

void ^?{}( KVPairs & kvp ) with ( kvp ) {                               // destructor
        for ( i; size ) free( data[i] );
        free( data );
        size = 0; max_size = 0; data = 0p;
}

void add_kv_pair( KVPairs & kv_pairs, char * k, char * v ) with ( kv_pairs ) {
        if ( max_size == 0 ) {
                max_size = 1;
                data = alloc( max_size );
        } else if ( size == max_size ) {
                max_size *= 2;
                data = alloc( max_size, data`realloc );
        }

        data[size].0 = alloc( strlen( k ) );
        data[size].1 = alloc( strlen( v ) );
        strcpy( data[size].0, k );
        strcpy( data[size].1, v );
        ++size;
}


bool comments( ifstream & in, char name[] ) {
        while () {
                in | name;
          if ( eof( in ) ) return true;
          if ( name[0] != '#' ) return false;
                in | nl;                                                                        // ignore remainder of line
        } // while
} // comments

// Parse configuration from a file formatted in shell style
KVPairs * parse_tabular_config_format( const char * config_file, size_t num_entries ) {
        * KVPairs kv_pairs = new( num_entries );

        ifstream in;
        try {
                open( in, config_file );                                        // open the configuration file for input

                char key[64];
                char value[256];

                while () {                                                                      // parameter names can appear in any order
                        // Must add check to see if already read in a key-value pair,
                        // once we switch to using hash table as intermediate storage
                  if ( comments( in, key ) ) break;                     // eof ?
                        in | value;

                        add_kv_pair( *kv_pairs, key, value );

                  if ( eof( in ) ) break;
                        in | nl;                                                                // ignore remainder of line
                } // for
        } catch( Open_Failure * ex; ex->istream == &in ) {
                delete( kv_pairs );
                throw *ex;
        } // try
        close( in );

        return kv_pairs;
}

// Parse configuration values from intermediate format
void parse_config( const char * config_file, config_entry entries[], size_t num_entries, config_format format ) {
        KVPairs * kv_pairs = 0p;
        choose ( format ) {
                case TABULAR_CONFIG:
                        kv_pairs = parse_tabular_config_format( config_file, num_entries );
        }

        int entries_so_far = 0;
        for ( i; kv_pairs->size ) {
          if ( entries_so_far == num_entries ) break;

                char * src_key, * src_value;
                [ src_key, src_value ] = kv_pairs->data[i];

                for ( j; num_entries ) {
                  if ( strcmp( src_key, entries[j].key ) != 0 ) continue;
                        // Parse the data
                        if ( !entries[j].parse( src_value, entries[j].variable ) ) {
                                Parse_Failure * ex = new( src_key, src_value );
                                delete( kv_pairs );
                                throw *ex;
                        }

                        // Validate the data
                        if ( !entries[j].validate( entries[j].variable ) ) {
                                Validation_Failure * ex = new( src_key, src_value );
                                delete( kv_pairs );
                                throw *ex;
                        }

                        ++entries_so_far;

                        break;
                }
        }
        if ( entries_so_far < num_entries ) {
                delete( kv_pairs );
                throw (Missing_Config_Entries){ num_entries - entries_so_far };
        }

        delete( kv_pairs );
} // processConfigFile


// *********************************** validation ***********************************


forall(T | Relational( T ))
bool is_nonnegative( T & value ) {
        T zero_val = 0;
        return value >= zero_val;
}

forall(T | Relational( T ))
bool is_positive( T & value ) {
        T zero_val = 0;
        return value > zero_val;
}

forall(T | Relational( T ))
bool is_nonpositive( T & value ) {
        T zero_val = 0;
        return value <= zero_val;
}

forall(T | Relational( T ))
bool is_negative( T & value ) {
        T zero_val = 0;
        return value < zero_val;
}


// Local Variables: //
// tab-width: 4 //
// compile-command: "cfa parseconfig.cfa" //
// End: //