Reorganised source files to make navigation easier

All tests still pass (slightly to my surprise)

src/arith/peano.c

@@ -132,10 +132,10 @@ struct cons_pointer simplify_ratio( struct stack_frame *frame,
                                     struct cons_pointer arg ) {
     struct cons_pointer result = arg;
     long int ddrv =
-        pointer2cell( pointer2cell( arg ).payload.ratio.dividend ).payload.
+        pointer2cell( pointer2cell( arg ).payload.ratio.dividend ).
-        integer.value, drrv =
+        payload.integer.value, drrv =
-        pointer2cell( pointer2cell( arg ).payload.ratio.divisor ).payload.
+        pointer2cell( pointer2cell( arg ).payload.ratio.divisor ).
-        integer.value, gcd = greatest_common_divisor( ddrv, drrv );
+        payload.integer.value, gcd = greatest_common_divisor( ddrv, drrv );
 
     if ( gcd > 1 ) {
         if ( drrv / gcd == 1 ) {
@@ -181,8 +181,8 @@ struct cons_pointer add_ratio_ratio( struct stack_frame *frame,
 
     if ( dr1v == dr2v ) {
         r = make_ratio( frame,
-                         make_integer( dd1v + dd2v ),
+                        make_integer( dd1v + dd2v ),
-                         cell1.payload.ratio.divisor );
+                        cell1.payload.ratio.divisor );
     } else {
         struct cons_pointer dd1vm = make_integer( dd1v * m1 ),
             dr1vm = make_integer( dr1v * m1 ),
@@ -404,8 +404,8 @@ struct cons_pointer multiply_integer_ratio( struct stack_frame *frame,
         ratio = make_ratio( frame, intarg, one ),
         result = multiply_ratio_ratio( frame, ratio, ratarg );
 
-    dec_ref( one);
+    dec_ref( one );
-    dec_ref( ratio);
+    dec_ref( ratio );
 
     return result;
 }
@@ -561,8 +561,8 @@ struct cons_pointer inverse( struct stack_frame *frame,
         case RATIOTV:
             result = make_ratio( frame,
                                  make_integer( 0 -
-                                               to_long_int( cell.payload.ratio.
+                                               to_long_int( cell.payload.
-                                                            dividend ) ),
+                                                            ratio.dividend ) ),
                                  cell.payload.ratio.divisor );
             break;
         case REALTV:
@@ -692,10 +692,10 @@ struct cons_pointer divide_ratio_ratio( struct stack_frame *frame,
                                         struct cons_pointer arg1,
                                         struct cons_pointer arg2 ) {
     struct cons_pointer i = make_ratio( frame,
-                                        pointer2cell( arg2 ).payload.ratio.
+                                        pointer2cell( arg2 ).payload.
-                                        divisor,
+                                        ratio.divisor,
-                                        pointer2cell( arg2 ).payload.ratio.
+                                        pointer2cell( arg2 ).payload.
-                                        dividend ), result =
+                                        ratio.dividend ), result =
         multiply_ratio_ratio( frame, arg1, i );
 
     dec_ref( i );
@@ -726,22 +726,23 @@ struct cons_pointer lisp_divide( struct
                 case EXCEPTIONTV:
                     result = frame->arg[1];
                     break;
-              case INTEGERTV: {
+                case INTEGERTV:{
-                    struct cons_pointer unsimplified = make_ratio( frame, frame->arg[0], frame->arg[1] );
+                        struct cons_pointer unsimplified =
-                    result = simplify_ratio(frame, unsimplified);
+                            make_ratio( frame, frame->arg[0], frame->arg[1] );
-              if (!eq(unsimplified,result)){
+                        result = simplify_ratio( frame, unsimplified );
-                dec_ref(unsimplified);
+                        if ( !eq( unsimplified, result ) ) {
-              }
+                            dec_ref( unsimplified );
-              }
+                        }
+                    }
                     break;
-              case RATIOTV: {
+                case RATIOTV:{
-                    struct cons_pointer one = make_integer( 1 );
+                        struct cons_pointer one = make_integer( 1 );
-                    struct cons_pointer ratio =
+                        struct cons_pointer ratio =
-                        make_ratio( frame, frame->arg[0], one );
+                            make_ratio( frame, frame->arg[0], one );
-                    result =
+                        result =
-                        divide_ratio_ratio( frame, ratio, frame->arg[1] );
+                            divide_ratio_ratio( frame, ratio, frame->arg[1] );
-                    dec_ref( ratio );
+                        dec_ref( ratio );
-              }
+                    }
                     break;
                 case REALTV:
                     result =
@@ -760,13 +761,14 @@ struct cons_pointer lisp_divide( struct
                 case EXCEPTIONTV:
                     result = frame->arg[1];
                     break;
-              case INTEGERTV: {
+                case INTEGERTV:{
-                    struct cons_pointer one = make_integer( 1 );
+                        struct cons_pointer one = make_integer( 1 );
-                    struct cons_pointer ratio =
+                        struct cons_pointer ratio =
-                        make_ratio( frame, frame->arg[1], one );
+                            make_ratio( frame, frame->arg[1], one );
-                    result = divide_ratio_ratio( frame, frame->arg[0], ratio );
+                        result =
-                    dec_ref( ratio );
+                            divide_ratio_ratio( frame, frame->arg[0], ratio );
-              }
+                        dec_ref( ratio );
+                    }
                     break;
                 case RATIOTV:
                     result =

src/memory/conspage.c

@@ -159,13 +159,14 @@ void free_cell( struct cons_pointer pointer ) {
         case SYMBOLTV:
             dec_ref( cell->payload.string.cdr );
             break;
-            case VECTORPOINTTV:
+        case VECTORPOINTTV:
             /* for vector space pointers, free the actual vector-space
              * object. Dangerous! */
 #ifdef DEBUG
-      fwprintf(stderr, L"About to free vector-space object at %ld\n", cell->payload.vectorp.address);
+            fwprintf( stderr, L"About to free vector-space object at %ld\n",
+                      cell->payload.vectorp.address );
 #endif
-            free( (void *)cell->payload.vectorp.address);
+            free( ( void * ) cell->payload.vectorp.address );
             break;
 
     }

src/memory/consspaceobject.c

@@ -136,10 +136,10 @@ void dump_object( FILE * output, struct cons_pointer pointer ) {
         case RATIOTV:
             fwprintf( output,
                       L"\t\tRational cell: value %ld/%ld, count %u\n",
-                      pointer2cell( cell.payload.ratio.dividend ).payload.
+                      pointer2cell( cell.payload.ratio.dividend ).
-                      integer.value,
+                      payload.integer.value,
-                      pointer2cell( cell.payload.ratio.divisor ).payload.
+                      pointer2cell( cell.payload.ratio.divisor ).
-                      integer.value, cell.count );
+                      payload.integer.value, cell.count );
             break;
         case READTV:
             fwprintf( output, L"\t\tInput stream\n" );

src/memory/vectorspace.c

@@ -29,14 +29,14 @@
  * NOTE that `tag` should be the vector-space tag of the particular type of
  * vector-space object, NOT `VECTORPOINTTAG`.
  */
-struct cons_pointer make_vec_pointer(char *tag, uint64_t address) {
+struct cons_pointer make_vec_pointer( char *tag, uint64_t address ) {
     struct cons_pointer pointer = allocate_cell( VECTORPOINTTAG );
     struct cons_space_object cell = pointer2cell( pointer );
 
     strncpy( &cell.payload.vectorp.tag.bytes[0], tag, 4 );
     cell.payload.vectorp.address = address;
 
-  return pointer;
+    return pointer;
 }
 
 /**
@@ -45,25 +45,25 @@ struct cons_pointer make_vec_pointer(char *tag, uint64_t address) {
  * NOTE that `tag` should be the vector-space tag of the particular type of
  * vector-space object, NOT `VECTORPOINTTAG`.
  */
-struct cons_pointer make_vso( char *tag, long int payload_size) {
+struct cons_pointer make_vso( char *tag, long int payload_size ) {
-  struct cons_pointer result = NIL;
+    struct cons_pointer result = NIL;
-  long int total_size = sizeof(struct vector_space_header) + payload_size;
+    long int total_size = sizeof( struct vector_space_header ) + payload_size;
 
-  struct vector_space_header *vso = malloc(total_size );
+    struct vector_space_header *vso = malloc( total_size );
 
-  if (vso != NULL) {
+    if ( vso != NULL ) {
-  strncpy( vso->tag.bytes[0], tag, TAGLENGTH );
+        strncpy( &vso->tag.bytes[0], tag, TAGLENGTH );
-  vso->vecp = make_vec_pointer(tag, (uint64_t)vso);
+        vso->vecp = make_vec_pointer( tag, ( uint64_t ) vso );
-  vso->size = payload_size;
+        vso->size = payload_size;
 
 #ifdef DEBUG
-  fwprintf(stderr, L"Allocated vector-space object of type %s, total size %ld, payload size %ld\n",
+        fwprintf( stderr,
-           tag, total_size, payload_size);
+                  L"Allocated vector-space object of type %s, total size %ld, payload size %ld\n",
+                  tag, total_size, payload_size );
 #endif
 
-    result = vso->vecp;
+        result = vso->vecp;
-  }
+    }
 
-  return result;
+    return result;
 }
-

src/memory/vectorspace.h

@@ -42,10 +42,10 @@
 
 #define pointer_to_vso(pointer)(vectorpointp(pointer)? pointer2cell(pointer).payload.vectorp.address : 0)
 
-struct cons_pointer make_vso( char *tag, long int payload_size);
+struct cons_pointer make_vso( char *tag, long int payload_size );
 
 struct vector_space_header {
-      union {
+    union {
         char bytes[TAGLENGTH];  /* the tag (type) of the
                                  * vector-space object this cell
                                  * points to, considered as bytes.
@@ -56,15 +56,13 @@ struct vector_space_header {
     } tag;
     struct cons_pointer vecp;   /* back pointer to the vector pointer
                                  * which uniquely points to this vso */
-  uint64_t size;                /* the size of my payload, in bytes */
+    uint64_t size;              /* the size of my payload, in bytes */
-  char mark;                    /* mark bit for marking/sweeping the
+    char mark;                  /* mark bit for marking/sweeping the
                                  * heap (not in this version) */
-  char payload;                 /* we'll malloc `size` bytes for payload,
+    char payload;               /* we'll malloc `size` bytes for payload,
                                  * `payload` is just the first of these.
                                  * TODO: this is almost certainly not
                                  * idiomatic C. */
 };
 
 #endif
-
-

src/ops/equal.c

@@ -80,8 +80,8 @@ bool equal( struct cons_pointer a, struct cons_pointer b ) {
                     && ( equal( cell_a->payload.string.cdr,
                                 cell_b->payload.string.cdr )
                          || ( end_of_string( cell_a->payload.string.cdr )
-                              && end_of_string( cell_b->payload.string.
+                              && end_of_string( cell_b->payload.
-                                                cdr ) ) );
+                                                string.cdr ) ) );
                 break;
             case INTEGERTV:
                 result =

src/ops/print.c

@@ -132,8 +132,8 @@ struct cons_pointer print( FILE * output, struct cons_pointer pointer ) {
         case LAMBDATV:
             print( output, make_cons( c_string_to_lisp_symbol( "lambda" ),
                                       make_cons( cell.payload.lambda.args,
-                                                 cell.payload.
+                                                 cell.payload.lambda.
-                                                 lambda.body ) ) );
+                                                 body ) ) );
             break;
         case NILTV:
             fwprintf( output, L"nil" );
@@ -141,8 +141,8 @@ struct cons_pointer print( FILE * output, struct cons_pointer pointer ) {
         case NLAMBDATV:
             print( output, make_cons( c_string_to_lisp_symbol( "nlambda" ),
                                       make_cons( cell.payload.lambda.args,
-                                                 cell.payload.
+                                                 cell.payload.lambda.
-                                                 lambda.body ) ) );
+                                                 body ) ) );
             break;
         case RATIOTV:
             print( output, cell.payload.ratio.dividend );