[patchlogo]

Debian patch tracking system

- xtrs - xtrs/4.9c-3.4 - direct patch of trs_imp_exp.c

xtrs (4.9c-3.4) trs_imp_exp.c

Summary

 trs_imp_exp.c |  452 +++++++++++++++++++++++++++++-----------------------------
 1 file changed, 226 insertions(+), 226 deletions(-)
download this patch

Patch contents

--- xtrs-4.9c.orig/trs_imp_exp.c
+++ xtrs-4.9c/trs_imp_exp.c
@@ -50,64 +50,64 @@
   int res;
   if (trs_emtsafe) {
     error("potentially dangerous emulator trap blocked");
-    REG_A = EACCES;
-    REG_F &= ~ZERO_MASK;
+    reg_A = EACCES;
+    reg_F &= ~ZERO_MASK;
     return;
   }
-  res = system((char *)mem_pointer(REG_HL, 0));
+  res = system((char *)mem_pointer(reg_HL, 0));
   if (res == -1) {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
   } else {
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   }
-  REG_BC = res;
+  reg_BC = res;
 }
 
 void do_emt_mouse()
 {
   int x, y;
   unsigned int buttons, sens;
-  switch (REG_B) {
+  switch (reg_B) {
   case 1:
     trs_get_mouse_pos(&x, &y, &buttons);
-    REG_HL = x;
-    REG_DE = y;
-    REG_A = buttons;
-    if (REG_A) {
-      REG_F &= ~ZERO_MASK;
+    reg_HL = x;
+    reg_DE = y;
+    reg_A = buttons;
+    if (reg_A) {
+      reg_F &= ~ZERO_MASK;
     } else {
-      REG_F |= ZERO_MASK;
+      reg_F |= ZERO_MASK;
     }
     break;
   case 2:
-    trs_set_mouse_pos(REG_HL, REG_DE);
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    trs_set_mouse_pos(reg_HL, reg_DE);
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
     break;
   case 3:
     trs_get_mouse_max(&x, &y, &sens);
-    REG_HL = x;
-    REG_DE = y;
-    REG_A = sens;
-    if (REG_A) {
-      REG_F &= ~ZERO_MASK;
+    reg_HL = x;
+    reg_DE = y;
+    reg_A = sens;
+    if (reg_A) {
+      reg_F &= ~ZERO_MASK;
     } else {
-      REG_F |= ZERO_MASK;
+      reg_F |= ZERO_MASK;
     }
     break;
   case 4:
-    trs_set_mouse_max(REG_HL, REG_DE, REG_C);
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    trs_set_mouse_max(reg_HL, reg_DE, reg_C);
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
     break;
   case 5:
-    REG_A = trs_get_mouse_type();
-    if (REG_A) {
-      REG_F &= ~ZERO_MASK;
+    reg_A = trs_get_mouse_type();
+    if (reg_A) {
+      reg_F &= ~ZERO_MASK;
     } else {
-      REG_F |= ZERO_MASK;
+      reg_F |= ZERO_MASK;
     }
     break;
   default:
@@ -118,28 +118,28 @@
 
 void do_emt_getddir()
 {
-  if (REG_HL + REG_BC > 0x10000 ||
-      REG_HL + strlen(trs_disk_dir) + 1 > REG_HL + REG_BC) {
-    REG_A = EFAULT;
-    REG_F &= ~ZERO_MASK;
-    REG_BC = 0xFFFF;
+  if (reg_HL + reg_BC > 0x10000 ||
+      reg_HL + strlen(trs_disk_dir) + 1 > reg_HL + reg_BC) {
+    reg_A = EFAULT;
+    reg_F &= ~ZERO_MASK;
+    reg_BC = 0xFFFF;
     return;
   }
-  strcpy((char *)mem_pointer(REG_HL, 1), trs_disk_dir);
-  REG_A = 0;
-  REG_F |= ZERO_MASK;
-  REG_BC = strlen(trs_disk_dir);
+  strcpy((char *)mem_pointer(reg_HL, 1), trs_disk_dir);
+  reg_A = 0;
+  reg_F |= ZERO_MASK;
+  reg_BC = strlen(trs_disk_dir);
 }
 
 void do_emt_setddir()
 {
   if (trs_emtsafe) {
     error("potentially dangerous emulator trap blocked");
-    REG_A = EACCES;
-    REG_F &= ~ZERO_MASK;
+    reg_A = EACCES;
+    reg_F &= ~ZERO_MASK;
     return;
   }
-  trs_disk_dir = strdup((char *)mem_pointer(REG_HL, 0));
+  trs_disk_dir = strdup((char *)mem_pointer(reg_HL, 0));
   if (trs_disk_dir[0] == '~' &&
       (trs_disk_dir[1] == '/' || trs_disk_dir[1] == '\0')) {
     char* home = getenv("HOME");
@@ -150,14 +150,14 @@
       trs_disk_dir = p;
     }
   }
-  REG_A = 0;
-  REG_F |= ZERO_MASK;
+  reg_A = 0;
+  reg_F |= ZERO_MASK;
 }
 
 void do_emt_open()
 {
   int fd, oflag, eoflag;
-  eoflag = REG_BC;
+  eoflag = reg_BC;
   switch (eoflag & EO_ACCMODE) {
   case EO_RDONLY:
   default:
@@ -177,52 +177,52 @@
 
   if (trs_emtsafe && oflag != O_RDONLY) {
     error("potentially dangerous emulator trap blocked");
-    REG_A = EACCES;
-    REG_F &= ~ZERO_MASK;
+    reg_A = EACCES;
+    reg_F &= ~ZERO_MASK;
     return;
   }
-  fd = open((char *)mem_pointer(REG_HL, 0), oflag, REG_DE);
+  fd = open((char *)mem_pointer(reg_HL, 0), oflag, reg_DE);
   if (fd >= 0) {
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   } else {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
   }
-  REG_DE = fd;
+  reg_DE = fd;
 }
 
 void do_emt_close()
 {
   int res;
-  res = close(REG_DE);
+  res = close(reg_DE);
   if (res >= 0) {
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   } else {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
   }
 }
 
 void do_emt_read()
 {
   int size;
-  if (REG_HL + REG_BC > 0x10000) {
-    REG_A = EFAULT;
-    REG_F &= ~ZERO_MASK;
-    REG_BC = 0xFFFF;
+  if (reg_HL + reg_BC > 0x10000) {
+    reg_A = EFAULT;
+    reg_F &= ~ZERO_MASK;
+    reg_BC = 0xFFFF;
     return;
   }
-  size = read(REG_DE, mem_pointer(REG_HL, 1), REG_BC);
+  size = read(reg_DE, mem_pointer(reg_HL, 1), reg_BC);
   if (size >= 0) {
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   } else {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
   }
-  REG_BC = size;
+  reg_BC = size;
 }
 
 
@@ -231,50 +231,50 @@
   int size;
   if (trs_emtsafe) {
     error("potentially dangerous emulator trap blocked");
-    REG_A = EACCES;
-    REG_F &= ~ZERO_MASK;
+    reg_A = EACCES;
+    reg_F &= ~ZERO_MASK;
     return;
   }
-  if (REG_HL + REG_BC > 0x10000) {
-    REG_A = EFAULT;
-    REG_F &= ~ZERO_MASK;
-    REG_BC = 0xFFFF;
+  if (reg_HL + reg_BC > 0x10000) {
+    reg_A = EFAULT;
+    reg_F &= ~ZERO_MASK;
+    reg_BC = 0xFFFF;
     return;
   }
-  size = write(REG_DE, mem_pointer(REG_HL, 0), REG_BC);
+  size = write(reg_DE, mem_pointer(reg_HL, 0), reg_BC);
   if (size >= 0) {
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   } else {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
   }
-  REG_BC = size;
+  reg_BC = size;
 }
 
 void do_emt_lseek()
 {
   int i;
   off_t offset;
-  if (REG_HL + 8 > 0x10000) {
-    REG_A = EFAULT;
-    REG_F &= ~ZERO_MASK;
+  if (reg_HL + 8 > 0x10000) {
+    reg_A = EFAULT;
+    reg_F &= ~ZERO_MASK;
     return;
   }
   offset = 0;
   for (i=0; i<8; i++) {
-    offset = offset + (mem_read(REG_HL + i) << i*8);
+    offset = offset + (mem_read(reg_HL + i) << i*8);
   }
-  offset = lseek(REG_DE, offset, REG_BC);
+  offset = lseek(reg_DE, offset, reg_BC);
   if (offset != (off_t) -1) {
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   } else {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
   }
-  for (i=REG_HL; i<8; i++) {
-    mem_write(REG_HL + i, offset & 0xff);
+  for (i=reg_HL; i<8; i++) {
+    mem_write(reg_HL + i, offset & 0xff);
     offset >>= 8;
   }
 }
@@ -283,40 +283,40 @@
 {
   char *msg;
   int size;
-  if (REG_HL + REG_BC > 0x10000) {
-    REG_A = EFAULT;
-    REG_F &= ~ZERO_MASK;
-    REG_BC = 0xFFFF;
+  if (reg_HL + reg_BC > 0x10000) {
+    reg_A = EFAULT;
+    reg_F &= ~ZERO_MASK;
+    reg_BC = 0xFFFF;
     return;
   }
   errno = 0;
-  msg = strerror(REG_A);
+  msg = strerror(reg_A);
   size = strlen(msg);
   if (errno != 0) {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
-  } else if (REG_BC < size + 2) {
-    REG_A = ERANGE;
-    REG_F &= ~ZERO_MASK;
-    size = REG_BC - 1;
-  } else {
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
-  }
-  memcpy(mem_pointer(REG_HL, 1), msg, size);
-  mem_write(REG_HL + size++, '\r');
-  mem_write(REG_HL + size, '\0');
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
+  } else if (reg_BC < size + 2) {
+    reg_A = ERANGE;
+    reg_F &= ~ZERO_MASK;
+    size = reg_BC - 1;
+  } else {
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
+  }
+  memcpy(mem_pointer(reg_HL, 1), msg, size);
+  mem_write(reg_HL + size++, '\r');
+  mem_write(reg_HL + size, '\0');
   if (errno == 0) {
-    REG_BC = size;
+    reg_BC = size;
   } else {
-    REG_BC = 0xFFFF;
+    reg_BC = 0xFFFF;
   }
 }
 
 void do_emt_time()
 {
   time_t now = time(0);
-  if (REG_A == 1) {
+  if (reg_A == 1) {
 #if __alpha
     struct tm *loctm = localtime(&now);
     now += loctm->tm_gmtoff;
@@ -349,11 +349,11 @@
       error("trouble computing local time in emt_time");
     }
 #endif
-  } else if (REG_A != 0) {
+  } else if (reg_A != 0) {
     error("unsupported function code to emt_time");
   }
-  REG_BC = (now >> 16) & 0xffff;
-  REG_DE = now & 0xffff;
+  reg_BC = (now >> 16) & 0xffff;
+  reg_DE = now & 0xffff;
 }
 
 void do_emt_opendir()
@@ -363,77 +363,77 @@
     if (dir[i] == NULL) break;
   }
   if (i == MAX_OPENDIR) {
-    REG_DE = 0xffff;
-    REG_A = EMFILE;
+    reg_DE = 0xffff;
+    reg_A = EMFILE;
     return;
   }
-  dir[i] = opendir((char *)mem_pointer(REG_HL, 0));
+  dir[i] = opendir((char *)mem_pointer(reg_HL, 0));
   if (dir[i] == NULL) {
-    REG_DE = 0xffff;
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
-  } else {
-    REG_DE = i;
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_DE = 0xffff;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
+  } else {
+    reg_DE = i;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   }
 }
 
 void do_emt_closedir()
 {
-  int i = REG_DE;
+  int i = reg_DE;
   int ok;
   if (i < 0 || i >= MAX_OPENDIR || dir[i] == NULL) {
-    REG_A = EBADF;
-    REG_F &= ~ZERO_MASK;
+    reg_A = EBADF;
+    reg_F &= ~ZERO_MASK;
     return;
   }	
   ok = closedir(dir[i]);
   dir[i] = NULL;
   if (ok >= 0) {
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   } else {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
   }
 }
 
 void do_emt_readdir()
 {
-  int size, i = REG_DE;
+  int size, i = reg_DE;
   struct dirent *result;
 
   if (i < 0 || i >= MAX_OPENDIR || dir[i] == NULL) {
-    REG_A = EBADF;
-    REG_F &= ~ZERO_MASK;
-    REG_BC = 0xFFFF;
+    reg_A = EBADF;
+    reg_F &= ~ZERO_MASK;
+    reg_BC = 0xFFFF;
     return;
   }	
-  if (REG_HL + REG_BC > 0x10000) {
-    REG_A = EFAULT;
-    REG_F &= ~ZERO_MASK;
-    REG_BC = 0xFFFF;
+  if (reg_HL + reg_BC > 0x10000) {
+    reg_A = EFAULT;
+    reg_F &= ~ZERO_MASK;
+    reg_BC = 0xFFFF;
     return;
   }
   result = readdir(dir[i]);
   if (result == NULL) {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
-    REG_BC = 0xFFFF;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
+    reg_BC = 0xFFFF;
     return;
   }
   size = strlen(result->d_name);
-  if (size + 1 > REG_BC) {
-    REG_A = ERANGE;
-    REG_F &= ~ZERO_MASK;
-    REG_BC = 0xFFFF;
+  if (size + 1 > reg_BC) {
+    reg_A = ERANGE;
+    reg_F &= ~ZERO_MASK;
+    reg_BC = 0xFFFF;
     return;
   }
-  strcpy((char *)mem_pointer(REG_HL, 1), result->d_name);
-  REG_A = 0;
-  REG_F |= ZERO_MASK;
-  REG_BC = size;
+  strcpy((char *)mem_pointer(reg_HL, 1), result->d_name);
+  reg_A = 0;
+  reg_F |= ZERO_MASK;
+  reg_BC = size;
 }
 
 void do_emt_chdir()
@@ -441,47 +441,47 @@
   int ok;
   if (trs_emtsafe) {
     error("potentially dangerous emulator trap blocked");
-    REG_A = EACCES;
-    REG_F &= ~ZERO_MASK;
+    reg_A = EACCES;
+    reg_F &= ~ZERO_MASK;
     return;
   }
-  ok = chdir((char *)mem_pointer(REG_HL, 0));
+  ok = chdir((char *)mem_pointer(reg_HL, 0));
   if (ok < 0) {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
   } else {
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   }
 }
 
 void do_emt_getcwd()
 {
   char *result;
-  if (REG_HL + REG_BC > 0x10000) {
-    REG_A = EFAULT;
-    REG_F &= ~ZERO_MASK;
-    REG_BC = 0xFFFF;
+  if (reg_HL + reg_BC > 0x10000) {
+    reg_A = EFAULT;
+    reg_F &= ~ZERO_MASK;
+    reg_BC = 0xFFFF;
     return;
   }
-  result = getcwd((char *)mem_pointer(REG_HL, 1), REG_BC);
+  result = getcwd((char *)mem_pointer(reg_HL, 1), reg_BC);
   if (result == NULL) {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
-    REG_BC = 0xFFFF;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
+    reg_BC = 0xFFFF;
     return;
   }
-  REG_A = 0;
-  REG_F |= ZERO_MASK;
-  REG_BC = strlen(result);
+  reg_A = 0;
+  reg_F |= ZERO_MASK;
+  reg_BC = strlen(result);
 }
 
 void do_emt_misc()
 {
-  switch (REG_A) {
+  switch (reg_A) {
   case 0:
     trs_disk_change_all();
-    REG_HL = trs_disk_changecount;
+    reg_HL = trs_disk_changecount;
     break;
   case 1:
     trs_exit();
@@ -493,60 +493,60 @@
     trs_reset(0);
     break;
   case 4:
-    REG_HL = trs_disk_changecount;
+    reg_HL = trs_disk_changecount;
     break;
   case 5:
-    REG_HL = trs_model;
+    reg_HL = trs_model;
     break;
   case 6:
-    REG_HL = trs_disk_getsize(REG_BC);
+    reg_HL = trs_disk_getsize(reg_BC);
     break;
   case 7:
-    trs_disk_setsize(REG_BC, REG_HL);
+    trs_disk_setsize(reg_BC, reg_HL);
     break;
   case 8:
-    REG_HL = trs_disk_getstep(REG_BC);
+    reg_HL = trs_disk_getstep(reg_BC);
     break;
   case 9:
-    trs_disk_setstep(REG_BC, REG_HL);
+    trs_disk_setstep(reg_BC, reg_HL);
     break;
   case 10:
-    REG_HL = grafyx_get_microlabs();
+    reg_HL = grafyx_get_microlabs();
     break;
   case 11:
-    grafyx_set_microlabs(REG_HL);
+    grafyx_set_microlabs(reg_HL);
     break;
   case 12:
-    REG_HL = z80_state.delay;
-    REG_BC = trs_autodelay;
+    reg_HL = z80_state.delay;
+    reg_BC = trs_autodelay;
     break;
   case 13:
-    z80_state.delay = REG_HL;
-    trs_autodelay = REG_BC;
+    z80_state.delay = reg_HL;
+    trs_autodelay = reg_BC;
     break;
   case 14:
-    REG_HL = stretch_amount;
+    reg_HL = stretch_amount;
     break;
   case 15:
-    stretch_amount = REG_HL;
+    stretch_amount = reg_HL;
     break;
   case 16:
-    REG_HL = trs_disk_doubler;
+    reg_HL = trs_disk_doubler;
     break;
   case 17:
-    trs_disk_doubler = REG_HL;
+    trs_disk_doubler = reg_HL;
     break;
   case 18:
-    REG_HL = sb_get_volume();
+    reg_HL = sb_get_volume();
     break;
   case 19:
-    sb_set_volume(REG_HL);
+    sb_set_volume(reg_HL);
     break;
   case 20:
-    REG_HL = trs_disk_truedam;
+    reg_HL = trs_disk_truedam;
     break;
   case 21:
-    trs_disk_truedam = REG_HL;
+    trs_disk_truedam = reg_HL;
     break;
   default:
     error("unsupported function code to emt_misc");
@@ -560,37 +560,37 @@
   off_t offset;
   if (trs_emtsafe) {
     error("potentially dangerous emulator trap blocked");
-    REG_A = EACCES;
-    REG_F &= ~ZERO_MASK;
+    reg_A = EACCES;
+    reg_F &= ~ZERO_MASK;
     return;
   }
-  if (REG_HL + 8 > 0x10000) {
-    REG_A = EFAULT;
-    REG_F &= ~ZERO_MASK;
+  if (reg_HL + 8 > 0x10000) {
+    reg_A = EFAULT;
+    reg_F &= ~ZERO_MASK;
     return;
   }
   offset = 0;
   for (i=0; i<8; i++) {
-    offset = offset + (mem_read(REG_HL + i) << i*8);
+    offset = offset + (mem_read(reg_HL + i) << i*8);
   }
-  result = ftruncate(REG_DE, offset);
+  result = ftruncate(reg_DE, offset);
   if (result == 0) {
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   } else {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
   }
 }
 
 void do_emt_opendisk()
 {
-  char *name = (char *)mem_pointer(REG_HL, 0);
+  char *name = (char *)mem_pointer(reg_HL, 0);
   char *qname;
   int i;
   int oflag, eoflag;
 
-  eoflag = REG_BC;
+  eoflag = reg_BC;
   switch (eoflag & EO_ACCMODE) {
   case EO_RDONLY:
   default:
@@ -610,8 +610,8 @@
 
   if (trs_emtsafe && oflag != O_RDONLY) {
     error("potentially dangerous emulator trap blocked");
-    REG_A = EACCES;
-    REG_F &= ~ZERO_MASK;
+    reg_A = EACCES;
+    reg_F &= ~ZERO_MASK;
     return;
   }
 
@@ -627,56 +627,56 @@
     if (!od[i].inuse) break;
   }
   if (i == MAX_OPENDISK) {
-    REG_DE = 0xffff;
-    REG_A = EMFILE;
-    REG_F &= ~ZERO_MASK;
+    reg_DE = 0xffff;
+    reg_A = EMFILE;
+    reg_F &= ~ZERO_MASK;
     free(qname);
     return;
   }
-  od[i].fd = open(qname, oflag, REG_DE);
+  od[i].fd = open(qname, oflag, reg_DE);
   free(qname);
   if (od[i].fd >= 0) {
     od[i].inuse = 1;
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   } else {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
   }
-  REG_DE = od[i].fd;
+  reg_DE = od[i].fd;
 }
 
 void do_emt_closedisk()
 {
   int i;
   int res;
-  if (REG_DE == 0xffff) {
+  if (reg_DE == 0xffff) {
     for (i = 0; i < MAX_OPENDISK; i++) {
       if (od[i].inuse) {
 	close(od[i].fd);
 	od[i].inuse = 0;
       }
     }
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
     return;
   }
 
   for (i = 0; i < MAX_OPENDISK; i++) {
-    if (od[i].inuse && od[i].fd == REG_DE) break;
+    if (od[i].inuse && od[i].fd == reg_DE) break;
   }
   if (i == MAX_OPENDISK) {
-    REG_A = EBADF;
-    REG_F &= ~ZERO_MASK;
+    reg_A = EBADF;
+    reg_F &= ~ZERO_MASK;
     return;
   }
   od[i].inuse = 0;
   res = close(od[i].fd);
   if (res >= 0) {
-    REG_A = 0;
-    REG_F |= ZERO_MASK;
+    reg_A = 0;
+    reg_F |= ZERO_MASK;
   } else {
-    REG_A = errno;
-    REG_F &= ~ZERO_MASK;
+    reg_A = errno;
+    reg_F &= ~ZERO_MASK;
   }
 }
page code/design/content is copyright (c) 2008 sean finney <seanius@debian.org>.
patches viewed/retrieved through this system are copyrighted by their respective authors.
browse git repo - clone git repo