Changeset 4a1bc44 for libcfa

Timestamp:

Aug 31, 2021, 4:34:22 PM (3 years ago)

Author:

Jacob Prud'homme <jafprudhomme@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, pthread-emulation, qualifiedEnum

Children:

dd698b4

Parents:

0660962c

Message:

Used in-English-order variable declaration syntax

File:

• libcfa/src/parseconfig.cfa (modified) (17 diffs)

libcfa/src/parseconfig.cfa

@@ -12 +12 @@
 static vtable(Missing_Config_Entries) Missing_Config_Entries_vt;
 
-void ?{}( Missing_Config_Entries & this, unsigned int num_missing ) {
+[ void ] ?{}( & Missing_Config_Entries this, unsigned int num_missing ) {
         this.virtual_table = &Missing_Config_Entries_vt;
         this.num_missing = num_missing;
 }
 
-void msg( Missing_Config_Entries * ex ) {
+[ void ] msg( * Missing_Config_Entries ex ) {
         serr | nlOff;
         serr | "The config file is missing " | ex->num_missing;
@@ -31 +31 @@
 static vtable(Parse_Failure) Parse_Failure_vt;
 
-void ?{}( Parse_Failure & this, char * failed_key, char * failed_value ) {
+[ void ] ?{}( & Parse_Failure this, [] char failed_key, [] char failed_value ) {
         this.virtual_table = &Parse_Failure_vt;
 
@@ -40 +40 @@
 }
 
-void ^?{}( Parse_Failure & this ) with ( this ) {
+[ void ] ^?{}( & Parse_Failure this ) with ( this ) {
         free( failed_key );
         free( failed_value );
 }
 
-void msg( Parse_Failure * ex ) {
+[ void ] msg( * Parse_Failure ex ) {
         serr | "Config entry " | ex->failed_key | " could not be parsed. It has value " | ex->failed_value | ".";
 }
@@ -52 +52 @@
 static vtable(Validation_Failure) Validation_Failure_vt;
 
-void ?{}( Validation_Failure & this, char * failed_key, char * failed_value ) {
+[ void ] ?{}( & Validation_Failure this, [] char failed_key, [] char failed_value ) {
         this.virtual_table = &Validation_Failure_vt;
 
@@ -61 +61 @@
 }
 
-void ^?{}( Validation_Failure & this ) with ( this ) {
+[ void ] ^?{}( & Validation_Failure this ) with ( this ) {
         free( failed_key );
         free( failed_value );
 }
 
-void msg( Validation_Failure * ex ) {
+[ void ] msg( * Validation_Failure ex ) {
         serr | "Config entry " | ex->failed_key | " could not be validated. It has value " | ex->failed_value | ".";
 }
@@ -77 +77 @@
 struct KVPairs {
         size_t size, max_size;
-        * [ char *, char * ] data;
+        * [ * char, * char ] data;
 };
 
-void ?{}( KVPairs & kvp ) with ( kvp ) {                                // default constructor
+[ void ] ?{}( & KVPairs kvp ) with ( kvp ) {                            // default constructor
         size = 0; max_size = 0; data = 0p;
 }
 
-void ?{}( KVPairs & kvp, size_t size ) {                                // initialization
+[ void ] ?{}( & KVPairs kvp, size_t size ) {                            // initialization
         kvp.[ size, max_size ] = [ 0, size ];
         kvp.data = alloc( size );
 }
 
-void ^?{}( KVPairs & kvp ) with ( kvp ) {                               // destructor
+[ void ] ^?{}( & KVPairs kvp ) with ( kvp ) {                           // destructor
         for ( i; size ) free( data[i] );
         free( data );
@@ -95 +95 @@
 }
 
-void add_kv_pair( KVPairs & kv_pairs, char * k, char * v ) with ( kv_pairs ) {
+[ void ] add_kv_pair( & KVPairs kv_pairs, [] char key, [] char value ) with ( kv_pairs ) {
         if ( max_size == 0 ) {
                 max_size = 1;
@@ -104 +104 @@
         }
 
-        data[size].0 = alloc( strlen( k ) );
-        data[size].1 = alloc( strlen( v ) );
-        strcpy( data[size].0, k );
-        strcpy( data[size].1, v );
+        data[size].0 = alloc( strlen( key ) );
+        data[size].1 = alloc( strlen( value ) );
+        strcpy( data[size].0, key );
+        strcpy( data[size].1, value );
         ++size;
 }
 
 
-bool comments( ifstream & in, char name[] ) {
+[ bool ] comments( & ifstream in, [] char name ) {
         while () {
                 in | name;
@@ -122 +122 @@
 
 // Parse configuration from a file formatted in tabular (CS 343) style
-KVPairs * parse_tabular_config_format( const char * config_file, size_t num_entries ) {
+[ * KVPairs ] parse_tabular_config_format( * const char config_file, size_t num_entries ) {
         // TODO: Change this to a unique_ptr when we fully support returning them (move semantics)
         * KVPairs kv_pairs = new( num_entries );
@@ -130 +130 @@
                 open( in, config_file );                                        // open the configuration file for input
 
-                char key[64];
-                char value[256];
+                [64] char key;
+                [256] char value;
 
                 while () {                                                                      // parameter names can appear in any order
@@ -154 +154 @@
 
 // Parse configuration values from intermediate format
-void parse_config( const char * config_file, config_entry entries[], size_t num_entries, config_format format ) {
+[ void ] parse_config( [] const char config_file, [] config_entry entries, size_t num_entries, config_format format ) {
         * KVPairs kv_pairs = 0p;
         choose ( format ) {
@@ -172 +172 @@
                         // Parse the data
                         if ( !entries[j].parse( src_value, entries[j].variable ) ) {
-                                Parse_Failure * ex = new( src_key, src_value );
+                                * Parse_Failure ex = new( src_key, src_value );
                                 delete( kv_pairs );
                                 throw *ex;
@@ -179 +179 @@
                         // Validate the data
                         if ( !entries[j].validate( entries[j].variable ) ) {
-                                Validation_Failure * ex = new( src_key, src_value );
+                                * Validation_Failure ex = new( src_key, src_value );
                                 delete( kv_pairs );
                                 throw *ex;
@@ -203 +203 @@
 
 forall(T | Relational( T ))
-bool is_nonnegative( T & value ) {
+[ bool ] is_nonnegative( & T value ) {
         T zero_val = 0;
         return value >= zero_val;
@@ -209 +209 @@
 
 forall(T | Relational( T ))
-bool is_positive( T & value ) {
+[ bool ] is_positive( & T value ) {
         T zero_val = 0;
         return value > zero_val;
@@ -215 +215 @@
 
 forall(T | Relational( T ))
-bool is_nonpositive( T & value ) {
+[ bool ] is_nonpositive( & T value ) {
         T zero_val = 0;
         return value <= zero_val;
@@ -221 +221 @@
 
 forall(T | Relational( T ))
-bool is_negative( T & value ) {
+[ bool ] is_negative( & T value ) {
         T zero_val = 0;
         return value < zero_val;