use GNU code conventions

1 files changed, 233 insertions, 232 deletions

diff --git a/mixlib/xmix_vm.c b/mixlib/xmix_vm.c
index c810a71..9eede01 100644
--- a/mixlib/xmix_vm.c
+++ b/mixlib/xmix_vm.c
@@ -1,22 +1,22 @@
 /* ---------------------- xmix_vm.c :
  * Implementation of the functions declared in xmix_vm.h
  * ------------------------------------------------------------------
- * Copyright (C) 2000 Free Software Foundation, Inc.
- *  
+ * Copyright (C) 2000, 2003 Free Software Foundation, Inc.
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
- *  
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *  
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *  
+ *
  */
 
 
@@ -32,23 +32,23 @@ G_INLINE_FUNC mix_device_t *
 get_dev_ (mix_vm_t *vm, mix_fspec_t type);
 
 G_INLINE_FUNC mix_address_t
-get_M_(const mix_vm_t *vm, const mix_ins_t *ins)
+get_M_ (const mix_vm_t *vm, const mix_ins_t *ins)
 {
   if ( ins->index == 0 )
     return ins->address;
   else
-    return mix_short_add(ins->address, 
-			 mix_word_to_short_fast(get_rI_(vm, ins->index)));
+    return mix_short_add (ins->address,
+                          mix_word_to_short_fast (get_rI_ (vm, ins->index)));
 }
 
 G_INLINE_FUNC mix_word_t
-get_V_(const mix_vm_t *vm, const mix_ins_t *ins)
+get_V_ (const mix_vm_t *vm, const mix_ins_t *ins)
 {
-  return mix_word_get_field(ins->fspec, get_cell_(vm, get_M_(vm,ins)));
+  return mix_word_get_field (ins->fspec, get_cell_ (vm, get_M_ (vm,ins)));
 }
 
 G_INLINE_FUNC mix_device_t *
-get_dev_ (mix_vm_t *vm, mix_fspec_t type) 
+get_dev_ (mix_vm_t *vm, mix_fspec_t type)
 {
   if (type >= BD_NO_) return NULL;
   if (vm->devices[type] == NULL)
@@ -58,165 +58,165 @@ get_dev_ (mix_vm_t *vm, mix_fspec_t type)
 
 /* Instruction handlers */
 
-static gboolean 
-nop_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+static gboolean
+nop_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
-  g_assert(ins->opcode == mix_opNOP);
-  inc_loc_(vm);
+  g_assert (ins->opcode == mix_opNOP);
+  inc_loc_ (vm);
   return TRUE;
 }
 
-static gboolean 
-add_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+static gboolean
+add_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
-  mix_word_t val = get_V_(vm, ins);
-  g_assert(ins->opcode == mix_opADD || ins->opcode == mix_opSUB);
-  if ( ins->opcode == mix_opSUB ) mix_word_reverse_sign(val);
-  if ( mix_word_add_and_carry(get_rA_(vm), val, NULL, &get_rA_(vm)) )
-    set_over_(vm,TRUE);
-  inc_loc_(vm);
+  mix_word_t val = get_V_ (vm, ins);
+  g_assert (ins->opcode == mix_opADD || ins->opcode == mix_opSUB);
+  if ( ins->opcode == mix_opSUB ) mix_word_reverse_sign (val);
+  if ( mix_word_add_and_carry (get_rA_ (vm), val, NULL, &get_rA_ (vm)) )
+    set_over_ (vm,TRUE);
+  inc_loc_ (vm);
   return TRUE;
 }
 
 
-static gboolean 
-mul_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+static gboolean
+mul_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
-  g_assert(ins->opcode == mix_opMUL);
-  mix_word_mul(get_rA_(vm), get_V_(vm,ins), &get_rA_(vm), &get_rX_(vm));
-  inc_loc_(vm);
+  g_assert (ins->opcode == mix_opMUL);
+  mix_word_mul (get_rA_ (vm), get_V_ (vm,ins), &get_rA_ (vm), &get_rX_ (vm));
+  inc_loc_ (vm);
   return TRUE;
 }
 
-static gboolean 
-div_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+static gboolean
+div_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
-  g_assert(ins->opcode == mix_opDIV);
-  if ( mix_word_div(get_rA_(vm), get_rX_(vm), get_V_(vm,ins),
-		    &get_rA_(vm), &get_rX_(vm)) )
-    set_over_(vm,TRUE);
-  inc_loc_(vm);
+  g_assert (ins->opcode == mix_opDIV);
+  if ( mix_word_div (get_rA_ (vm), get_rX_ (vm), get_V_ (vm,ins),
+                     &get_rA_ (vm), &get_rX_ (vm)) )
+    set_over_ (vm,TRUE);
+  inc_loc_ (vm);
   return TRUE;
 }
 
-static gboolean 
-spc_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+static gboolean
+spc_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
-  g_assert(ins->opcode == mix_opSPC);
-  
-  switch (mix_ins_id_from_ins(*ins)) {
-  case mix_HLT: halt_(vm, TRUE); break;
+  g_assert (ins->opcode == mix_opSPC);
+
+  switch (mix_ins_id_from_ins (*ins)) {
+  case mix_HLT: halt_ (vm, TRUE); break;
   case mix_CHAR:
-    { 
-      guint32 num = mix_word_magnitude(get_rA_(vm));
-      mix_char_t z = mix_ascii_to_char('0');
+    {
+      guint32 num = mix_word_magnitude (get_rA_ (vm));
+      mix_char_t z = mix_ascii_to_char ('0');
       guint i;
       for (i = 5; 0 < i; --i, num /= 10)
-	mix_word_set_byte(&get_rX_(vm), i, z + num % 10);
+	mix_word_set_byte (&get_rX_ (vm), i, z + num % 10);
       for (i = 5; 0 < i; --i, num /= 10)
-	mix_word_set_byte(&get_rA_(vm), i, z + num % 10);
+	mix_word_set_byte (&get_rA_ (vm), i, z + num % 10);
       break;
     }
-  case mix_NUM: 
-    { 
+  case mix_NUM:
+    {
       guint i;
       mix_word_t num = MIX_WORD_ZERO;
       mix_word_t ten = 10;
       for (i = 1; i <= 5; ++i) {
-	mix_word_mul(ten, num, NULL, &num);
-	mix_word_add_and_carry(num, mix_word_get_byte(get_rA_(vm),i)%10,
-			       NULL, &num);
+	mix_word_mul (ten, num, NULL, &num);
+	mix_word_add_and_carry (num, mix_word_get_byte (get_rA_ (vm),i)%10,
+                                NULL, &num);
       }
       for (i = 1; i <= 5; ++i) {
-	mix_word_mul(ten, num, NULL, &num);
-	mix_word_add_and_carry(num, mix_word_get_byte(get_rX_(vm),i)%10,
-			       NULL, &num);
+	mix_word_mul (ten, num, NULL, &num);
+	mix_word_add_and_carry (num, mix_word_get_byte (get_rX_ (vm),i)%10,
+                                NULL, &num);
       }
-      set_rA_(vm,
-	      mix_word_is_negative(get_rA_(vm)) ? mix_word_negative(num):num);
+      set_rA_ (vm, mix_word_is_negative (get_rA_ (vm)) ?
+               mix_word_negative (num) : num);
       break;
     }
   default: return FALSE;
   }
-  inc_loc_(vm);
+  inc_loc_ (vm);
   return TRUE;
 }
 
-static gboolean 
-sla_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+static gboolean
+sla_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
-  mix_short_t n = get_M_(vm,ins);
-  
-  g_assert(ins->opcode == mix_opSLx);
-  g_return_val_if_fail(mix_short_is_positive(n), FALSE);
-  
-  switch ( mix_ins_id_from_ins(*ins) ) {
+  mix_short_t n = get_M_ (vm,ins);
+
+  g_assert (ins->opcode == mix_opSLx);
+  g_return_val_if_fail (mix_short_is_positive (n), FALSE);
+
+  switch ( mix_ins_id_from_ins (*ins) ) {
   case mix_SLA:
-    mix_word_shift_left(get_rA_(vm), MIX_WORD_ZERO, n, &get_rA_(vm), NULL);
+    mix_word_shift_left (get_rA_ (vm), MIX_WORD_ZERO, n, &get_rA_ (vm), NULL);
     break;
   case mix_SRA:
-    mix_word_shift_right(get_rA_(vm), MIX_WORD_ZERO, n, &get_rA_(vm), NULL);
+    mix_word_shift_right (get_rA_ (vm), MIX_WORD_ZERO, n, &get_rA_ (vm), NULL);
     break;
   case mix_SLAX:
-    mix_word_shift_left(get_rA_(vm), get_rX_(vm), n, 
-			&get_rA_(vm), &get_rX_(vm));
+    mix_word_shift_left (get_rA_ (vm), get_rX_ (vm), n,
+                         &get_rA_ (vm), &get_rX_ (vm));
     break;
   case mix_SRAX:
-    mix_word_shift_right(get_rA_(vm), get_rX_(vm), n, 
-			&get_rA_(vm), &get_rX_(vm));
+    mix_word_shift_right (get_rA_ (vm), get_rX_ (vm), n,
+                          &get_rA_ (vm), &get_rX_ (vm));
     break;
   case mix_SLC:
-    mix_word_shift_left_circular(get_rA_(vm), get_rX_(vm), n, 
-				 &get_rA_(vm), &get_rX_(vm));
+    mix_word_shift_left_circular (get_rA_ (vm), get_rX_ (vm), n,
+                                  &get_rA_ (vm), &get_rX_ (vm));
     break;
   case mix_SRC:
-    mix_word_shift_right_circular(get_rA_(vm), get_rX_(vm), n, 
-				  &get_rA_(vm), &get_rX_(vm));
+    mix_word_shift_right_circular (get_rA_ (vm), get_rX_ (vm), n,
+                                   &get_rA_ (vm), &get_rX_ (vm));
     break;
   default:
     return FALSE;
   }
-  
-  inc_loc_(vm);
+
+  inc_loc_ (vm);
   return TRUE;
 }
 
-static gboolean 
-mov_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+static gboolean
+mov_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
-  mix_short_t from = get_M_(vm,ins), 
-    to = mix_word_to_short_fast(get_rI_(vm,1));
+  mix_short_t from = get_M_ (vm,ins),
+    to = mix_word_to_short_fast (get_rI_ (vm,1));
   guint k, delta = ins->fspec;
-  
-  g_assert(ins->opcode == mix_opMOVE);
-  g_return_val_if_fail(mix_short_is_positive(from), FALSE);
-  g_return_val_if_fail(mix_short_is_positive(to), FALSE);
-  g_return_val_if_fail(MEMOK_(from + delta -1), FALSE);
-  g_return_val_if_fail(MEMOK_(to + delta - 1), FALSE);
-  
+
+  g_assert (ins->opcode == mix_opMOVE);
+  g_return_val_if_fail (mix_short_is_positive (from), FALSE);
+  g_return_val_if_fail (mix_short_is_positive (to), FALSE);
+  g_return_val_if_fail (MEMOK_ (from + delta -1), FALSE);
+  g_return_val_if_fail (MEMOK_ (to + delta - 1), FALSE);
+
   for (k = 0; k < delta; ++k)
-    set_cell_(vm, to+k, get_cell_(vm, from+k));
-  set_rI_(vm, 1, to+delta);
-  inc_loc_(vm);
+    set_cell_ (vm, to+k, get_cell_ (vm, from+k));
+  set_rI_ (vm, 1, to+delta);
+  inc_loc_ (vm);
   return TRUE;
 }
 
 static gboolean
-lda_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+lda_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
   gint r = 0;
   mix_word_t val;
-  mix_ins_id_t id = mix_ins_id_from_ins(*ins);
-    
-  g_assert(id >= mix_LDA && id <= mix_LDXN);
-  
-  val = get_V_(vm, ins);
-  if ( id > mix_LDX && mix_fspec_left(ins->fspec) == 0) 
-    mix_word_reverse_sign(val);
+  mix_ins_id_t id = mix_ins_id_from_ins (*ins);
+
+  g_assert (id >= mix_LDA && id <= mix_LDXN);
+
+  val = get_V_ (vm, ins);
+  if ( id > mix_LDX && mix_fspec_left (ins->fspec) == 0)
+    mix_word_reverse_sign (val);
   if ( (id > mix_LDA && id < mix_LDX) || (id > mix_LDAN && id < mix_LDXN) )
     /* Bytes 1-3 of I regs are always null */
-    val = mix_word_set_field(mix_fspec_new(1,3),MIX_WORD_ZERO,val);
-        
+    val = mix_word_set_field (mix_fspec_new (1,3),MIX_WORD_ZERO,val);
+
   switch (id) {
   case mix_LDA: case mix_LDAN: r = A_; break;
   case mix_LDX: case mix_LDXN: r = X_; break;
@@ -226,331 +226,332 @@ lda_handler_(mix_vm_t *vm, const mix_ins_t *ins)
   case mix_LD4: case mix_LD4N: r = I4_; break;
   case mix_LD5: case mix_LD5N: r = I5_; break;
   case mix_LD6: case mix_LD6N: r = I6_; break;
-  default: g_assert_not_reached();
+  default: g_assert_not_reached ();
   }
-  set_reg_(vm, r, val);
-  inc_loc_(vm);
+  set_reg_ (vm, r, val);
+  inc_loc_ (vm);
   return TRUE;
 }
 
 
 static gboolean
-sta_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+sta_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
-  mix_address_t addr = get_M_(vm, ins);
-  mix_ins_id_t id = mix_ins_id_from_ins(*ins);
+  mix_address_t addr = get_M_ (vm, ins);
+  mix_ins_id_t id = mix_ins_id_from_ins (*ins);
   mix_word_t from;
-  
-  g_assert(id >= mix_STA && id <= mix_STZ);
+
+  g_assert (id >= mix_STA && id <= mix_STZ);
   switch (id) {
-  case mix_STA: from = get_rA_(vm); break;
-  case mix_STX: from = get_rX_(vm); break;
-  case mix_STJ: from = get_rJ_(vm); break;
+  case mix_STA: from = get_rA_ (vm); break;
+  case mix_STX: from = get_rX_ (vm); break;
+  case mix_STJ: from = get_rJ_ (vm); break;
   case mix_STZ: from = MIX_WORD_ZERO; break;
-  default: from = get_rI_(vm, id - mix_ST1 + 1); break;
+  default: from = get_rI_ (vm, id - mix_ST1 + 1); break;
   }
-  set_cell_(vm, addr,
-	    mix_word_store_field(ins->fspec, from,  get_cell_(vm, addr)));
-  inc_loc_(vm);
+  set_cell_ (vm, addr,
+             mix_word_store_field (ins->fspec, from,  get_cell_ (vm, addr)));
+  inc_loc_ (vm);
   return TRUE;
 }
 
-static gboolean 
+static gboolean
 jbs_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
   g_assert (ins->opcode == mix_opJBUS);
   g_return_val_if_fail (ins->fspec < BD_NO_, TRUE);
   g_return_val_if_fail (get_dev_ (vm, ins->fspec) != NULL, TRUE);
   if ( mix_device_busy (get_dev_ (vm, ins->fspec)) ) {
-      set_rJ_(vm, get_loc_ (vm));
-      set_loc_ (vm, get_M_ (vm, ins));
+    set_rJ_ (vm, get_loc_ (vm));
+    set_loc_ (vm, get_M_ (vm, ins));
   } else inc_loc_ (vm);
   return TRUE;
 }
 
-static gboolean 
-ioc_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+static gboolean
+ioc_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
   mix_address_t addr;
   mix_device_t *dev;
   gboolean result;
-  
-  g_assert(ins->opcode == mix_opIOC);
+
+  g_assert (ins->opcode == mix_opIOC);
   addr = get_M_ (vm, ins);
   g_return_val_if_fail (ins->fspec < BD_NO_, TRUE);
   dev = get_dev_ (vm, ins->fspec);
   g_return_val_if_fail (dev != NULL, TRUE);
   result =
     mix_device_ioc (dev, addr);
-    
-  inc_loc_(vm);
+
+  inc_loc_ (vm);
   return result;
 }
 
-static gboolean 
+static gboolean
 inp_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
   mix_address_t addr;
   mix_device_t *dev;
   gboolean result;
-  
-  g_assert(ins->opcode == mix_opIN);
+
+  g_assert (ins->opcode == mix_opIN);
   addr = get_M_ (vm, ins);
   g_return_val_if_fail (ins->fspec < BD_NO_, TRUE);
-  g_return_val_if_fail (MEMOK_(addr), TRUE);
+  g_return_val_if_fail (MEMOK_ (addr), TRUE);
   dev = get_dev_ (vm, ins->fspec);
   g_return_val_if_fail ( dev != NULL, TRUE);
-  g_return_val_if_fail (MEM_CELLS_NO_ - addr > mix_device_block_size(dev),
+  g_return_val_if_fail (MEM_CELLS_NO_ - addr > mix_device_block_size (dev),
 			TRUE);
   result =
     mix_device_read (dev, get_cell_ptr_ (vm, addr));
-    
-  inc_loc_(vm);
+
+  inc_loc_ (vm);
   return result;
 }
 
-static gboolean 
-out_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+static gboolean
+out_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
   mix_address_t addr;
   mix_device_t *dev;
   gboolean result;
-  
-  g_assert(ins->opcode == mix_opOUT);
+
+  g_assert (ins->opcode == mix_opOUT);
   addr = get_M_ (vm, ins);
   g_return_val_if_fail (ins->fspec < BD_NO_, TRUE);
-  g_return_val_if_fail (MEMOK_(addr), TRUE);
+  g_return_val_if_fail (MEMOK_ (addr), TRUE);
   dev = get_dev_ (vm, ins->fspec);
   g_return_val_if_fail ( dev != NULL, TRUE);
-  g_return_val_if_fail (MEM_CELLS_NO_ - addr > mix_device_block_size(dev),
+  g_return_val_if_fail (MEM_CELLS_NO_ - addr > mix_device_block_size (dev),
 			TRUE);
   result =
     mix_device_write (dev, get_cell_ptr_ (vm, addr));
-  
-  inc_loc_(vm);
+
+  inc_loc_ (vm);
   return result;
 }
 
-static gboolean 
-jrd_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+static gboolean
+jrd_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
-  g_assert(ins->opcode == mix_opJRED);
+  g_assert (ins->opcode == mix_opJRED);
   g_return_val_if_fail (ins->fspec < BD_NO_, TRUE);
   g_return_val_if_fail (get_dev_ (vm, ins->fspec) != NULL, TRUE);
   inc_loc_ (vm);
-  if ( !mix_device_busy (get_dev_ (vm, ins->fspec)) ) 
+  if ( !mix_device_busy (get_dev_ (vm, ins->fspec)) )
     {
-      set_rJ_(vm, get_loc_(vm));
+      set_rJ_ (vm, get_loc_ (vm));
       set_loc_ (vm, get_M_ (vm, ins));
     }
   return TRUE;
 }
 
 static gboolean
-jmp_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+jmp_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
   gboolean jump = FALSE;
-  mix_address_t addr = get_M_(vm, ins);
-  mix_ins_id_t id = mix_ins_id_from_ins(*ins);
-  
-  g_assert(ins->opcode == mix_opJMP);
-  g_return_val_if_fail(MEMOK_(addr), FALSE);
+  mix_address_t addr = get_M_ (vm, ins);
+  mix_ins_id_t id = mix_ins_id_from_ins (*ins);
+
+  g_assert (ins->opcode == mix_opJMP);
+  g_return_val_if_fail (MEMOK_ (addr), FALSE);
   switch ( id ) {
   case mix_JMP:
   case mix_JSJ:
     jump = TRUE;
     break;
   case mix_JOV:
-    jump = get_over_(vm);
-    if (jump) set_over_(vm, FALSE);
+    jump = get_over_ (vm);
+    if (jump) set_over_ (vm, FALSE);
     break;
   case mix_JNOV:
-    jump = !get_over_(vm);
-    set_over_(vm, FALSE);
+    jump = !get_over_ (vm);
+    set_over_ (vm, FALSE);
     break;
   case mix_JL:
-    jump = ( get_cmp_(vm) == mix_LESS );
+    jump = ( get_cmp_ (vm) == mix_LESS );
     break;
   case mix_JE:
-    jump = ( get_cmp_(vm) == mix_EQ );
+    jump = ( get_cmp_ (vm) == mix_EQ );
     break;
   case mix_JG:
-    jump = ( get_cmp_(vm) == mix_GREAT );
+    jump = ( get_cmp_ (vm) == mix_GREAT );
     break;
   case mix_JGE:
-    jump = ( get_cmp_(vm) != mix_LESS );
+    jump = ( get_cmp_ (vm) != mix_LESS );
     break;
   case mix_JNE:
-    jump = ( get_cmp_(vm) != mix_EQ );
+    jump = ( get_cmp_ (vm) != mix_EQ );
     break;
   case mix_JLE:
-    jump = ( get_cmp_(vm) != mix_GREAT );
+    jump = ( get_cmp_ (vm) != mix_GREAT );
     break;
   default:
     return FALSE;
   }
-  
-  inc_loc_(vm);
+
+  inc_loc_ (vm);
   if ( jump ) {
-    if ( id != mix_JSJ ) set_rJ_(vm, get_loc_(vm));
-    set_loc_(vm, addr);
+    if ( id != mix_JSJ ) set_rJ_ (vm, get_loc_ (vm));
+    set_loc_ (vm, addr);
   }
   return TRUE;
 }
 
 static gboolean
-jpx_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+jpx_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
   gboolean jump = FALSE;
-  mix_address_t addr = get_M_(vm, ins);
-  mix_ins_id_t id = mix_ins_id_from_ins(*ins);
+  mix_address_t addr = get_M_ (vm, ins);
+  mix_ins_id_t id = mix_ins_id_from_ins (*ins);
   mix_word_t val;
-    
-  g_assert(ins->opcode >= mix_opJAx || ins->opcode <= mix_opJXx);
-  g_return_val_if_fail(MEMOK_(addr), FALSE);
-  
+
+  g_assert (ins->opcode >= mix_opJAx || ins->opcode <= mix_opJXx);
+  g_return_val_if_fail (MEMOK_ (addr), FALSE);
+
   switch (ins->opcode) {
-  case mix_opJAx: val = get_rA_(vm); break;
-  case mix_opJXx: val = get_rX_(vm); break;
-  default: val = get_rI_(vm, ins->opcode - mix_opJAx);
+  case mix_opJAx: val = get_rA_ (vm); break;
+  case mix_opJXx: val = get_rX_ (vm); break;
+  default: val = get_rI_ (vm, ins->opcode - mix_opJAx);
   }
-  
+
   switch (id) {
   case mix_JAN: case mix_JXN:
   case mix_J1N: case mix_J2N: case mix_J3N:
   case mix_J4N: case mix_J5N: case mix_J6N:
-    jump = mix_word_is_negative(val) && val != MIX_WORD_MINUS_ZERO;
+    jump = mix_word_is_negative (val) && val != MIX_WORD_MINUS_ZERO;
     break;
   case mix_JAZ: case mix_JXZ:
   case mix_J1Z: case mix_J2Z: case mix_J3Z:
   case mix_J4Z: case mix_J5Z: case mix_J6Z:
-    jump = mix_word_magnitude(val) == MIX_WORD_ZERO;
+    jump = mix_word_magnitude (val) == MIX_WORD_ZERO;
     break;
   case mix_JAP: case mix_JXP:
   case mix_J1P: case mix_J2P: case mix_J3P:
   case mix_J4P: case mix_J5P: case mix_J6P:
-    jump = mix_word_is_positive(val) && val != MIX_WORD_ZERO;
+    jump = mix_word_is_positive (val) && val != MIX_WORD_ZERO;
     break;
   case mix_JANN: case mix_JXNN:
   case mix_J1NN: case mix_J2NN: case mix_J3NN:
   case mix_J4NN: case mix_J5NN: case mix_J6NN:
-    jump = mix_word_magnitude(val) == MIX_WORD_ZERO 
-      || mix_word_is_positive(val);
+    jump = mix_word_magnitude (val) == MIX_WORD_ZERO
+      || mix_word_is_positive (val);
     break;
   case mix_JANZ: case mix_JXNZ:
   case mix_J1NZ: case mix_J2NZ: case mix_J3NZ:
   case mix_J4NZ: case mix_J5NZ: case mix_J6NZ:
-    jump = mix_word_magnitude(val) != MIX_WORD_ZERO;
+    jump = mix_word_magnitude (val) != MIX_WORD_ZERO;
     break;
   case mix_JANP: case mix_JXNP:
   case mix_J1NP: case mix_J2NP: case mix_J3NP:
   case mix_J4NP: case mix_J5NP: case mix_J6NP:
-    jump = mix_word_magnitude(val) == MIX_WORD_ZERO
-      || mix_word_is_negative(val);
+    jump = mix_word_magnitude (val) == MIX_WORD_ZERO
+      || mix_word_is_negative (val);
     break;
   default:
     return FALSE;
   }
-  
-  inc_loc_(vm);
+
+  inc_loc_ (vm);
   if ( jump ) {
-    set_rJ_(vm, get_loc_(vm));
-    set_loc_(vm, addr);
+    set_rJ_ (vm, get_loc_ (vm));
+    set_loc_ (vm, addr);
   }
   return TRUE;
 }
 
 static gboolean
-ina_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+ina_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
-  mix_word_t val = mix_short_to_word_fast(get_M_(vm, ins));
-  mix_ins_id_t id = mix_ins_id_from_ins(*ins);
+  mix_word_t val = mix_short_to_word_fast (get_M_ (vm, ins));
+  mix_ins_id_t id = mix_ins_id_from_ins (*ins);
   gint r;
-  
-  g_assert(id >= mix_INCA && id <= mix_ENNX);
-  
+
+  g_assert (id >= mix_INCA && id <= mix_ENNX);
+
   switch (ins->opcode) {
   case mix_opINCA: r = A_; break;
   case mix_opINCX: r = X_; break;
   default: r = I1_ + ins->opcode - mix_opINC1;
   }
-  
+
   switch (id) {
   case mix_ENTA: case mix_ENTX:
     break;
-  case mix_ENT1: case mix_ENT2: case mix_ENT3: 
-  case mix_ENT4: case mix_ENT5: case mix_ENT6: 
-    val = mix_word_set_field(mix_fspec_new(1,3), MIX_WORD_ZERO, val);
+  case mix_ENT1: case mix_ENT2: case mix_ENT3:
+  case mix_ENT4: case mix_ENT5: case mix_ENT6:
+    val = mix_word_set_field (mix_fspec_new (1,3), MIX_WORD_ZERO, val);
     break;
   case mix_INCA: case mix_INCX:
-    if ( mix_word_add_and_carry(val, get_reg_(vm, r), NULL, &val) )
-      set_over_(vm, TRUE);
+    if ( mix_word_add_and_carry (val, get_reg_ (vm, r), NULL, &val) )
+      set_over_ (vm, TRUE);
     break;
-  case mix_INC1: case mix_INC2: case mix_INC3: 
+  case mix_INC1: case mix_INC2: case mix_INC3:
   case mix_INC4: case mix_INC5: case mix_INC6:
-    mix_word_add_and_carry(val, get_reg_(vm,r), NULL, &val);
-    val = mix_word_set_field(mix_fspec_new(1,3), MIX_WORD_ZERO, val);
+    mix_word_add_and_carry (val, get_reg_ (vm,r), NULL, &val);
+    val = mix_word_set_field (mix_fspec_new (1,3), MIX_WORD_ZERO, val);
     break;
   case mix_DECA: case mix_DECX:
-    if ( mix_word_add_and_carry(mix_word_negative(val), get_reg_(vm, r),
-				NULL, &val) )
-      set_over_(vm, TRUE);
+    if ( mix_word_add_and_carry (mix_word_negative (val), get_reg_ (vm, r),
+                                 NULL, &val) )
+      set_over_ (vm, TRUE);
     break;
-  case mix_DEC1: case mix_DEC2: case mix_DEC3: 
-  case mix_DEC4: case mix_DEC5: case mix_DEC6: 
-    mix_word_add_and_carry(mix_word_negative(val), get_reg_(vm,r), NULL, &val);
-    val = mix_word_set_field(mix_fspec_new(1,3), MIX_WORD_ZERO, val);
+  case mix_DEC1: case mix_DEC2: case mix_DEC3:
+  case mix_DEC4: case mix_DEC5: case mix_DEC6:
+    mix_word_add_and_carry (mix_word_negative (val), get_reg_ (vm,r),
+                            NULL, &val);
+    val = mix_word_set_field (mix_fspec_new (1,3), MIX_WORD_ZERO, val);
     break;
-  case mix_ENN1: case mix_ENN2: case mix_ENN3: 
-  case mix_ENN4: case mix_ENN5: case mix_ENN6: 
-    val = mix_word_set_field(mix_fspec_new(1,3), MIX_WORD_ZERO, val);
+  case mix_ENN1: case mix_ENN2: case mix_ENN3:
+  case mix_ENN4: case mix_ENN5: case mix_ENN6:
+    val = mix_word_set_field (mix_fspec_new (1,3), MIX_WORD_ZERO, val);
     /* fallthrough */
   case mix_ENNA: case mix_ENNX:
-    mix_word_reverse_sign(val);
+    mix_word_reverse_sign (val);
     break;
   default:
     return FALSE;
   }
-  set_reg_(vm, r, val);
-  inc_loc_(vm);
+  set_reg_ (vm, r, val);
+  inc_loc_ (vm);
   return TRUE;
 }
 
 static gboolean
-cmp_handler_(mix_vm_t *vm, const mix_ins_t *ins)
+cmp_handler_ (mix_vm_t *vm, const mix_ins_t *ins)
 {
-  g_assert(ins->opcode >= mix_opCMPA && ins->opcode <= mix_opCMPX);
+  g_assert (ins->opcode >= mix_opCMPA && ins->opcode <= mix_opCMPX);
 
   if ( ins->fspec == 0 ) { /* shortcut: +0 == -0 */
-    set_cmp_(vm, mix_EQ);
+    set_cmp_ (vm, mix_EQ);
   } else {
-    mix_word_t v = get_V_(vm, ins);
+    mix_word_t v = get_V_ (vm, ins);
     mix_word_t reg;
     mix_cmpflag_t flag;
-    
+
     switch (ins->opcode) {
     case mix_opCMPA:
-      reg = get_rA_(vm);
+      reg = get_rA_ (vm);
       break;
     case mix_opCMPX:
-      reg = get_rX_(vm);
+      reg = get_rX_ (vm);
       break;
     default:
-      reg = get_rI_(vm, ins->opcode - mix_opCMPA);
+      reg = get_rI_ (vm, ins->opcode - mix_opCMPA);
       break;
     }
-    reg = mix_word_get_field(ins->fspec, reg);
-    mix_word_add_and_carry(reg, mix_word_negative(v), NULL, &reg);
-    if ( mix_word_magnitude(reg) == MIX_WORD_ZERO ) flag = mix_EQ;
-    else if ( mix_word_is_positive(reg) ) flag = mix_GREAT;
+    reg = mix_word_get_field (ins->fspec, reg);
+    mix_word_add_and_carry (reg, mix_word_negative (v), NULL, &reg);
+    if ( mix_word_magnitude (reg) == MIX_WORD_ZERO ) flag = mix_EQ;
+    else if ( mix_word_is_positive (reg) ) flag = mix_GREAT;
     else flag = mix_LESS;
-    set_cmp_(vm, flag);
+    set_cmp_ (vm, flag);
   }
-  inc_loc_(vm);
+  inc_loc_ (vm);
   return TRUE;
 }
 
-ins_handler_t_ ins_handlers_[MIX_BYTE_MAX + 1] = { 
+ins_handler_t_ ins_handlers_[MIX_BYTE_MAX + 1] = {
   nop_handler_, add_handler_, add_handler_, mul_handler_, div_handler_,
   spc_handler_, sla_handler_, mov_handler_, lda_handler_, lda_handler_,
   lda_handler_, lda_handler_, lda_handler_, lda_handler_, lda_handler_,
@@ -563,5 +564,5 @@ ins_handler_t_ ins_handlers_[MIX_BYTE_MAX + 1] = {
   jpx_handler_, jpx_handler_, jpx_handler_, ina_handler_, ina_handler_,
   ina_handler_, ina_handler_, ina_handler_, ina_handler_, ina_handler_,
   ina_handler_, cmp_handler_, cmp_handler_, cmp_handler_, cmp_handler_,
-  cmp_handler_, cmp_handler_, cmp_handler_, cmp_handler_, 
+  cmp_handler_, cmp_handler_, cmp_handler_, cmp_handler_,
 };