source: libcfa/src/parseconfig.cfa @ 52c6891

enumforall-pointer-decayjacob/cs343-translation
Last change on this file since 52c6891 was 52c6891, checked in by Jacob Prud'homme <jafprudhomme@…>, 9 months ago

Freed KVPairs in case of error

  • Property mode set to 100644
File size: 3.9 KB
Line 
1#include <fstream.hfa>
2#include <parseargs.hfa>
3#include <stdlib.hfa>
4#include <string.h>
5#include "parseconfig.hfa"
6
7
8// *********************************** exceptions ***********************************
9
10
11EHM_VIRTUAL_TABLE(Validation_Failure, Validation_Failure_main_table);
12void ?{}( Validation_Failure & this, config_entry & entry ) with ( entry ) {
13        this.virtual_table = &Validation_Failure_main_table;
14        this.key = key;
15        this.variable = variable;
16}
17void throwValidation_Failure( config_entry & entry ) {
18        Validation_Failure exc = { entry };
19}
20
21
22// *********************************** main code ***********************************
23
24
25struct KVPairs {
26        int size, max_size;
27        * [ char *, char * ] data;
28};
29void ?{}( KVPairs & kvp ) with ( kvp ) {                                // default constructor
30        size = 0; max_size = 0; data = 0p;
31}
32void ?{}( KVPairs & kvp, int size ) {                                   // initialization
33        kvp.[ size, max_size ] = [ 0, size ];
34        kvp.data = alloc( size );
35}
36/*
37void ?{}( KVPairs & kvp, KVPairs val ) with( val ) {    // copy, deep
38        kvp.[ size, max_size ] = [ size, max_size ];
39        kvp.data = alloc( size, data );
40}
41*/
42void ^?{}( KVPairs & kvp ) with ( kvp ) {                               // destructor
43        free( data );
44        size = 0; max_size = 0; data = 0p;
45}
46
47void add_kv_pair( KVPairs kv_pairs, char * k, char * v ) with ( kv_pairs ) {
48        if ( size == max_size ) {
49                max_size *= 2;
50                data = resize( data, max_size );
51        }
52
53        data[size] = [ k, v ];
54        ++size;
55}
56
57bool comments( ifstream & in, char * name ) {
58        while () {
59                in | name;
60          if ( fail( in ) ) return true;
61          if ( name[0] != '#' ) break;
62                in | nl;        // ignore remainder of line
63        } // for
64        return false;
65} // comments
66
67// Parse configuration from a file formatted in shell style
68KVPairs & parse_shell_config_format( const char * config_file, size_t num_entries ) {
69        * KVPairs kv_pairs;// = { num_entries };
70
71        ifstream in;
72        try {
73                open( in, config_file );                                                        // open the configuration file for input
74
75                while () {
76                        char * key;
77                        char * value;
78                  if ( comments( in, key ) ) break;                     // eof ?
79                        // Should we just overwrite duplicate config entries? Having a hash map would make this much easier
80                        in | value;
81
82                        add_kv_pair( *kv_pairs, key, value );
83
84                  if ( fail( in ) ) break;
85                        in | nl; // ignore remainder of line
86                } // for
87        } catch( Open_Failure * ex; ex->istream == &in ) {
88                ^kv_pairs{};
89                exit | "Error: could not open input file \"" | config_file | "\"";
90        } // try
91        close( in );
92
93        return *kv_pairs;
94}
95
96// Parse configuration values from intermediate format
97void parse_config( const char * config_file, config_entry entries[], size_t num_entries ) {
98        KVPairs kv_pairs = parse_shell_config_format( config_file, num_entries );
99
100        int entries_so_far = 0;
101        for ( i; kv_pairs.size ) {
102          if ( entries_so_far == num_entries ) break;
103
104                char * src_key, * src_value;
105                [ src_key, src_value ] = kv_pairs.data[i];
106
107                for ( j; num_entries ) {
108                  if ( strcmp( src_key, entries[j].key ) != 0 ) continue;
109                        if ( entries[j].parse( src_value, entries[j].variable ) ) {
110                                ++entries_so_far;
111
112                                // Validate the parsed data, if necessary
113                                if ( entries[j].validate != 0p ) {
114                                        if ( !entries[j].validate( entries[j].variable ) ) throwValidation_Failure( entries[j] );
115                                }
116
117                                break;
118                        }
119
120                        serr | "Value '" | src_value | "' for key '" | src_key | "' could not be parsed";
121                }
122        }
123} // processConfigFile
124
125
126// *********************************** validation ***********************************
127
128
129forall(T | Relational( T ))
130bool is_nonnegative( T & value ) {
131        T zero_val = 0;
132        return value >= zero_val;
133}
134
135forall(T | Relational( T ))
136bool is_positive( T & value ) {
137        T zero_val = 0;
138        return value > zero_val;
139}
140
141forall(T | Relational( T ))
142bool is_nonpositive( T & value ) {
143        T zero_val = 0;
144        return value <= zero_val;
145}
146
147forall(T | Relational( T ))
148bool is_negative( T & value ) {
149        T zero_val = 0;
150        return value < zero_val;
151}
152
153
154// Local Variables: //
155// tab-width: 4 //
156// compile-command: "cfa parseconfig.cfa" //
157// End: //
Note: See TracBrowser for help on using the repository browser.