home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / minix / update~1.z / update~1 / gkernel / kernel / kernel.diff
Encoding:
Text File  |  1989-08-24  |  26.7 KB  |  988 lines
  1. *** /tmp/,RCSt1a27031    Thu Aug 24 00:01:21 1989
  2. --- proc.c    Thu Aug 17 17:29:27 1989
  3. ***************
  4. *** 24,29 ****
  5. --- 24,33 ----
  6.   #include "proc.h"
  7.   #include "k_proto.h"
  8.   
  9. + #ifdef ATARI_ST
  10. + unsigned long busy_map = 0L;
  11. + #endif
  12. + 
  13.   static int mini_rec(int, struct proc *, int, message *);
  14.   static void cp_mess(int, struct proc *, message *, struct proc *, message *); 
  15.   
  16. ***************
  17. *** 46,52 ****
  18.   message *m_ptr;            /* interrupt message to send to the task */
  19.   {
  20.   /* An interrupt has occurred.  Schedule the task that handles it. */
  21. ! 
  22.   
  23.   #ifdef i8088
  24.     /* Re-enable the 8259A interrupt controller. */
  25. --- 50,59 ----
  26.   message *m_ptr;            /* interrupt message to send to the task */
  27.   {
  28.   /* An interrupt has occurred.  Schedule the task that handles it. */
  29. ! #if 1
  30. !   int i, n;
  31. !   unsigned long old_map, this_bit;
  32. ! #endif
  33.   
  34.   #ifdef i8088
  35.     /* Re-enable the 8259A interrupt controller. */
  36. ***************
  37. *** 56,63 ****
  38. --- 63,101 ----
  39.         port_out(INT2_CTL, ENABLE);
  40.   #endif
  41.   
  42. + #if 0
  43.     /* Try to send the interrupt message to the indicated task. */
  44.     mini_send(HARDWARE, proc_addr(HARDWARE), task, m_ptr);
  45. + #else
  46. +   /* Try to send the interrupt message to the indicated task. */
  47. +   this_bit = 1 << (-task);
  48. +   if (mini_send(HARDWARE, proc_addr(HARDWARE), task, m_ptr) != OK) {
  49. +     /* The message could not be sent to the task; it was not waiting. */
  50. +     old_map = busy_map;    /* save original map of busy tasks */
  51. +     if (task == CLOCK) {
  52. +         lost_ticks++;
  53. +     } else {
  54. +         busy_map |= this_bit;        /* mark task as busy */
  55. +         task_mess[-task] = m_ptr;    /* record message pointer */
  56. +     }
  57. +   } else {
  58. +     /* Hardware interrupt was successfully sent as a message. */
  59. +     busy_map &= ~this_bit;    /* turn off the bit in case it was on */
  60. +     old_map = busy_map;
  61. +   }
  62. + 
  63. +   /* See if any tasks that were previously busy are now listening for msgs. */
  64. +   if (old_map != 0) {
  65. +     for (i = 2, this_bit = 4; i <= NR_TASKS; this_bit <<= 1, i++) {
  66. +         /* Check each task looking for one with a pending interrupt. */
  67. +         if ( old_map & this_bit ) {
  68. +             /* Task 'i' has a pending interrupt. */
  69. +             n = mini_send(HARDWARE, proc_addr(HARDWARE), -i, task_mess[i]);
  70. +             if (n == OK) busy_map &= ~this_bit;
  71. +         }
  72. +     }
  73. +   }
  74. + #endif
  75.   
  76.   #ifndef ATARI_ST
  77.     /* If a task has just been readied and a user is running, run the task. */
  78. ***************
  79. *** 103,109 ****
  80.     }
  81.   
  82.     if (function & RECEIVE) {
  83. !     n = mini_rec(caller,  rp, src_dest, m_ptr);  /* func = RECEIVE or BOTH */
  84.       rp->p_reg[RET_REG] = n;
  85.     }
  86.   }
  87. --- 141,147 ----
  88.     }
  89.   
  90.     if (function & RECEIVE) {
  91. !     n = mini_rec(caller, rp, src_dest, m_ptr);  /* func = RECEIVE or BOTH */
  92.       rp->p_reg[RET_REG] = n;
  93.     }
  94.   }
  95. ***************
  96. *** 127,133 ****
  97.     vir_clicks vlo, vhi;        /* virtual clicks containing message to send */
  98.     vir_clicks len;        /* length of data segment in clicks */
  99.     int s;
  100. ! 
  101.     /* User processes are only allowed to send to FS and MM.  Check for this. */
  102.     if (caller >= LOW_USER && (dest != FS_PROC_NR && dest != MM_PROC_NR))
  103.       return(E_BAD_DEST);
  104. --- 165,171 ----
  105.     vir_clicks vlo, vhi;        /* virtual clicks containing message to send */
  106.     vir_clicks len;        /* length of data segment in clicks */
  107.     int s;
  108. !   
  109.     /* User processes are only allowed to send to FS and MM.  Check for this. */
  110.     if (caller >= LOW_USER && (dest != FS_PROC_NR && dest != MM_PROC_NR))
  111.       return(E_BAD_DEST);
  112. ***************
  113. *** 152,183 ****
  114.     }
  115.   
  116.     /* Check to see if 'dest' is blocked waiting for this message. */
  117. !   s = lock();
  118. !   if ( (dest_ptr->p_flags & RECEIVING) &&
  119. !         (dest_ptr->p_flags & SENDING) == 0 &&
  120. !         (dest_ptr->p_getfrom == ANY || dest_ptr->p_getfrom == caller) ) {
  121.       /* Destination is indeed waiting for this message. */
  122.       CopyMess(caller, caller_ptr, m_ptr, dest_ptr, dest_ptr->p_messbuf);
  123.       dest_ptr->p_flags &= ~RECEIVING;    /* deblock destination */
  124. -      restore(s);
  125.       if (dest_ptr->p_flags == 0) ready(dest_ptr);
  126.     } else {
  127.       /* Destination is not waiting.  Block and queue caller. */
  128. !     if (caller == HARDWARE) {
  129. !         restore(s);
  130. !         if (dest == CLOCK)
  131. !             lost_ticks++;
  132. ! #ifdef NEEDED
  133. !         else if (task_mess[-dest])
  134. !             printf("interrupt for task %d lost\n", dest);
  135. ! #endif
  136. !         else
  137. !             task_mess[-dest] = m_ptr;    /* record message pointer */
  138. !         return(E_OVERRUN);
  139. !     }
  140.       caller_ptr->p_messbuf = m_ptr;
  141. !     if (caller_ptr->p_flags == 0)
  142. !         unready(caller_ptr);
  143.       caller_ptr->p_flags |= SENDING;
  144.   
  145.       /* Process is now blocked.  Put in on the destination's queue. */
  146. --- 190,211 ----
  147.     }
  148.   
  149.     /* Check to see if 'dest' is blocked waiting for this message. */
  150. ! /*   s = lock(); */
  151. !   if ( (dest_ptr->p_flags & RECEIVING) && (dest_ptr->p_flags & SENDING) == 0 &&
  152. !         (dest_ptr->p_getfrom == ANY || dest_ptr->p_getfrom == caller)){
  153.       /* Destination is indeed waiting for this message. */
  154.       CopyMess(caller, caller_ptr, m_ptr, dest_ptr, dest_ptr->p_messbuf);
  155.       dest_ptr->p_flags &= ~RECEIVING;    /* deblock destination */
  156.       if (dest_ptr->p_flags == 0) ready(dest_ptr);
  157.     } else {
  158.       /* Destination is not waiting.  Block and queue caller. */
  159. !       if (caller == HARDWARE)
  160. !       {
  161. !       /* restore(s); */
  162. !       return(E_OVERRUN);
  163. !       }
  164.       caller_ptr->p_messbuf = m_ptr;
  165. !     if (caller_ptr->p_flags == 0) unready(caller_ptr);
  166.       caller_ptr->p_flags |= SENDING;
  167.   
  168.       /* Process is now blocked.  Put in on the destination's queue. */
  169. ***************
  170. *** 189,195 ****
  171.           next_ptr->p_sendlink = caller_ptr;
  172.       }
  173.       caller_ptr->p_sendlink = NIL_PROC;
  174. !     restore(s);
  175.     }
  176.     return(OK);
  177.   }
  178. --- 217,223 ----
  179.           next_ptr->p_sendlink = caller_ptr;
  180.       }
  181.       caller_ptr->p_sendlink = NIL_PROC;
  182. ! /*        restore(s); */
  183.     }
  184.     return(OK);
  185.   }
  186. ***************
  187. *** 211,231 ****
  188.    * Calls from the tasks, MM, and FS are trusted.
  189.    */
  190.   
  191. !   register struct proc *sender_ptr, *prev_ptr;
  192.     int sender;
  193. ! 
  194.     if ((caller_ptr->p_flags & SENDING) == 0) {
  195. !      if (caller < 0 && task_mess[-caller]) {
  196.       /* we have a HARDWARE message waiting */
  197.       if (src == ANY || src == HARDWARE) {
  198.           sender_ptr = proc_addr(HARDWARE);
  199.           CopyMess(HARDWARE, sender_ptr, task_mess[-caller],
  200.                       caller_ptr, m_ptr);
  201. !         task_mess[-caller] = 0;
  202.           return(OK);
  203.       }
  204.        }
  205. !      /* Check to see if a message from desired source is already available. */
  206.        sender_ptr = caller_ptr->p_callerq;
  207.        while (sender_ptr != NIL_PROC) {
  208.       sender = (sender_ptr - proc) - NR_TASKS;
  209. --- 239,261 ----
  210.    * Calls from the tasks, MM, and FS are trusted.
  211.    */
  212.   
  213. !   register struct proc *sender_ptr, *previous_ptr;
  214.     int sender;
  215. !   unsigned long this_bit;
  216. !   
  217. !   /* Check to see if a message from desired source is already available. */
  218.     if ((caller_ptr->p_flags & SENDING) == 0) {
  219. !      if (caller < 0 && (busy_map & (this_bit = (1L << (-caller))))) {
  220.       /* we have a HARDWARE message waiting */
  221.       if (src == ANY || src == HARDWARE) {
  222.           sender_ptr = proc_addr(HARDWARE);
  223.           CopyMess(HARDWARE, sender_ptr, task_mess[-caller],
  224.                       caller_ptr, m_ptr);
  225. !         busy_map &= ~this_bit;
  226.           return(OK);
  227.       }
  228.        }
  229. !      /* not a hardware message, but one is avail */
  230.        sender_ptr = caller_ptr->p_callerq;
  231.        while (sender_ptr != NIL_PROC) {
  232.       sender = (sender_ptr - proc) - NR_TASKS;
  233. ***************
  234. *** 232,247 ****
  235.       if (src == ANY || src == sender) {
  236.           /* An acceptable message has been found. */
  237.           CopyMess(sender, sender_ptr, sender_ptr->p_messbuf,
  238. !                     caller_ptr, m_ptr);
  239.           sender_ptr->p_flags &= ~SENDING;    /* deblock sender */
  240.           if (sender_ptr->p_flags == 0) ready(sender_ptr);
  241.           if (sender_ptr == caller_ptr->p_callerq)
  242.               caller_ptr->p_callerq = sender_ptr->p_sendlink;
  243.           else
  244. !             prev_ptr->p_sendlink = sender_ptr->p_sendlink;
  245.           return(OK);
  246.       }
  247. !     prev_ptr = sender_ptr;
  248.       sender_ptr = sender_ptr->p_sendlink;
  249.        }
  250.     }
  251. --- 262,277 ----
  252.       if (src == ANY || src == sender) {
  253.           /* An acceptable message has been found. */
  254.           CopyMess(sender, sender_ptr, sender_ptr->p_messbuf,
  255. !                  caller_ptr, m_ptr);
  256.           sender_ptr->p_flags &= ~SENDING;    /* deblock sender */
  257.           if (sender_ptr->p_flags == 0) ready(sender_ptr);
  258.           if (sender_ptr == caller_ptr->p_callerq)
  259.               caller_ptr->p_callerq = sender_ptr->p_sendlink;
  260.           else
  261. !             previous_ptr->p_sendlink = sender_ptr->p_sendlink;
  262.           return(OK);
  263.       }
  264. !     previous_ptr = sender_ptr;
  265.       sender_ptr = sender_ptr->p_sendlink;
  266.        }
  267.     }
  268. ***************
  269. *** 249,265 ****
  270.     /* No suitable message is available.  Block the process trying to receive. */
  271.     caller_ptr->p_getfrom = src;
  272.     caller_ptr->p_messbuf = m_ptr;
  273. !   if (caller_ptr->p_flags == 0)
  274. !     unready(caller_ptr);
  275.     caller_ptr->p_flags |= RECEIVING;
  276.   
  277.     /* If MM has just blocked and there are kernel signals pending, now is the
  278.      * time to tell MM about them, since it will be able to accept the message.
  279.      */
  280. !   if (sig_procs > 0 && caller == MM_PROC_NR && src == ANY) 
  281. !   {
  282. !       inform();
  283. !       pick_proc();
  284.     }
  285.     return(OK);
  286.   }
  287. --- 279,293 ----
  288.     /* No suitable message is available.  Block the process trying to receive. */
  289.     caller_ptr->p_getfrom = src;
  290.     caller_ptr->p_messbuf = m_ptr;
  291. !   if (caller_ptr->p_flags == 0) unready(caller_ptr);
  292.     caller_ptr->p_flags |= RECEIVING;
  293.   
  294.     /* If MM has just blocked and there are kernel signals pending, now is the
  295.      * time to tell MM about them, since it will be able to accept the message.
  296.      */
  297. !   if (sig_procs > 0 && caller == MM_PROC_NR && src == ANY) {
  298. !     inform();
  299. !     pick_proc();
  300.     }
  301.     return(OK);
  302.   }
  303. ***************
  304. *** 315,335 ****
  305.    */
  306.   
  307.     register int q;        /* TASK_Q, SERVER_Q, or USER_Q */
  308. !   register int s;
  309. ! 
  310. !   s = lock();            /* disable interrupts */
  311. ! 
  312. !   DEBUG(if (rp->p_flags != 0)
  313. !     panic("ready with flags. proc =", (rp-proc)-NR_TASKS);
  314. !   );
  315. !   DEBUG({ register struct proc *xp;
  316. !     for (q = 0; q < NQ; q++)
  317. !         for (xp = rdy_head[q]; xp != NIL_PROC; xp = xp->p_nextready)
  318. !             if (xp == rp)
  319. !                 panic("ready, but already ready. proc =",
  320. !                     (rp-proc)-NR_TASKS);
  321. !   });
  322.   
  323.     if (rp < &proc[NR_TASKS])
  324.       q = TASK_Q;
  325.     else if (rp < &proc[NR_TASKS+LOW_USER])
  326. --- 343,351 ----
  327.    */
  328.   
  329.     register int q;        /* TASK_Q, SERVER_Q, or USER_Q */
  330. !   int  old_state;
  331.   
  332. +   old_state = lock();        /* disable interrupts */
  333.     if (rp < &proc[NR_TASKS])
  334.       q = TASK_Q;
  335.     else if (rp < &proc[NR_TASKS+LOW_USER])
  336. ***************
  337. *** 348,354 ****
  338.       rdy_tail[q]->p_nextready = rp;    /* add to tail of nonempty queue */
  339.     rdy_tail[q] = rp;        /* new entry has no successor */
  340.     rp->p_nextready = NIL_PROC;
  341. !   restore(s);            /* restore interrupts to previous state */
  342.   }
  343.   
  344.   
  345. --- 364,370 ----
  346.       rdy_tail[q]->p_nextready = rp;    /* add to tail of nonempty queue */
  347.     rdy_tail[q] = rp;        /* new entry has no successor */
  348.     rp->p_nextready = NIL_PROC;
  349. !   restore(old_state);        /* restore interrupts to previous state */
  350.   }
  351.   
  352.   
  353. ***************
  354. *** 361,374 ****
  355.   /* A process has blocked. */
  356.   
  357.     register struct proc *xp;
  358. !   int q, s;
  359.   
  360. !   s = lock();            /* disable interrupts */
  361.   
  362. -   DEBUG(if (rp->p_flags != 0)
  363. -     panic("unready with flags. proc =", (rp-proc)-NR_TASKS);
  364. -   );
  365. - 
  366.     if (rp < &proc[NR_TASKS])
  367.       q = TASK_Q;
  368.     else if (rp < &proc[NR_TASKS+LOW_USER])
  369. --- 377,386 ----
  370.   /* A process has blocked. */
  371.   
  372.     register struct proc *xp;
  373. !   int q, old_state;
  374.   
  375. !   old_state = lock();            /* disable interrupts */
  376.   
  377.     if (rp < &proc[NR_TASKS])
  378.       q = TASK_Q;
  379.     else if (rp < &proc[NR_TASKS+LOW_USER])
  380. ***************
  381. *** 381,396 ****
  382.       q = USER_Q;
  383.   
  384.     if ( (xp = rdy_head[q]) == NIL_PROC) {
  385. !     restore(s);
  386.       return;
  387.     }
  388.     if (xp == rp) {
  389.       /* Remove head of queue */
  390.       rdy_head[q] = xp->p_nextready;
  391. ! #ifdef ATARI_ST
  392. !     if (rp == proc_ptr)
  393. ! #endif
  394. !         pick_proc();
  395.     } else {
  396.       /* Search body of queue.  A process can be made unready even if it is
  397.        * not running by being sent a signal that kills it.
  398. --- 393,405 ----
  399.       q = USER_Q;
  400.   
  401.     if ( (xp = rdy_head[q]) == NIL_PROC) {
  402. !     restore(old_state);
  403.       return;
  404.     }
  405.     if (xp == rp) {
  406.       /* Remove head of queue */
  407.       rdy_head[q] = xp->p_nextready;
  408. !     if (rp == proc_ptr) pick_proc();
  409.     } else {
  410.       /* Search body of queue.  A process can be made unready even if it is
  411.        * not running by being sent a signal that kills it.
  412. ***************
  413. *** 397,405 ****
  414.        */
  415.       while (xp->p_nextready != rp)
  416.           if ( (xp = xp->p_nextready) == NIL_PROC) {
  417. !             DEBUG(panic("unready, but not ready, proc =",
  418. !                 (rp-proc)-NR_TASKS));
  419. !             restore(s);
  420.               return;
  421.           }
  422.       xp->p_nextready = xp->p_nextready->p_nextready;
  423. --- 406,412 ----
  424.        */
  425.       while (xp->p_nextready != rp)
  426.           if ( (xp = xp->p_nextready) == NIL_PROC) {
  427. !             restore(old_state);
  428.               return;
  429.           }
  430.       xp->p_nextready = xp->p_nextready->p_nextready;
  431. ***************
  432. *** 406,412 ****
  433.       while (xp->p_nextready != NIL_PROC) xp = xp->p_nextready;
  434.       rdy_tail[q] = xp;
  435.     }
  436. !   restore(s);            /* restore interrupts to previous state */
  437.   }
  438.   
  439.   
  440. --- 413,419 ----
  441.       while (xp->p_nextready != NIL_PROC) xp = xp->p_nextready;
  442.       rdy_tail[q] = xp;
  443.     }
  444. !   restore(old_state);            /* restore interrupts to prev state */
  445.   }
  446.   
  447.   
  448. ***************
  449. *** 420,430 ****
  450.    * possibly promoting another user to head of the queue.
  451.    */
  452.   
  453. !   register int s;
  454.   
  455. !   s = lock();            /* disable interrupts */
  456.     if (rdy_head[USER_Q] == NIL_PROC) {
  457. !     restore(s);        /* restore interrupts to previous state */
  458.       return;
  459.     }
  460.   
  461. --- 427,437 ----
  462.    * possibly promoting another user to head of the queue.
  463.    */
  464.   
  465. !   int old_state;
  466.   
  467. !   old_state = lock();            /* disable interrupts */
  468.     if (rdy_head[USER_Q] == NIL_PROC) {
  469. !     restore(old_state);        /* restore interrupts to prev state */
  470.       return;
  471.     }
  472.   
  473. ***************
  474. *** 434,440 ****
  475.     rdy_head[USER_Q] = rdy_head[USER_Q]->p_nextready;
  476.     rdy_tail[USER_Q]->p_nextready = NIL_PROC;
  477.     pick_proc();
  478. !   restore(s);            /* restore interrupts to previous state */
  479.   }
  480.   
  481.   #ifdef ATARI_ST
  482. --- 441,447 ----
  483.     rdy_head[USER_Q] = rdy_head[USER_Q]->p_nextready;
  484.     rdy_tail[USER_Q]->p_nextready = NIL_PROC;
  485.     pick_proc();
  486. !   restore(old_state);            /* restore interrupts to prev state */
  487.   }
  488.   
  489.   #ifdef ATARI_ST
  490. *** /tmp/,RCSt1a27031    Thu Aug 24 00:02:07 1989
  491. --- stvdu.c    Thu Aug 17 17:56:05 1989
  492. ***************
  493. *** 74,89 ****
  494.   {
  495.     if (tp->tty_outleft == 0)
  496.       return(1);
  497.     vducursor(0);
  498.     do {
  499. !     if (tp->tty_inhibited == TRUE) {
  500. !         vducursor(1);
  501. !         return(0);
  502. !     }
  503. !     vduput(*((char *)tp->tty_phys));
  504.                   /* write 1 byte to terminal */
  505. !     tp->tty_phys++;        /* advance physical data pointer */
  506. !     tp->tty_cum++;        /* number of characters printed */
  507.     } while (--tp->tty_outleft != 0);
  508.     vducursor(1);
  509.     return(1);
  510. --- 74,93 ----
  511.   {
  512.     if (tp->tty_outleft == 0)
  513.       return(1);
  514. +   if (tp->tty_inhibited == TRUE)
  515. +       return(0);
  516. + 
  517.     vducursor(0);
  518.     do {
  519. !       if (tp->tty_inhibited == TRUE) 
  520. !       {
  521. !       vducursor(1);
  522. !       return(0);
  523. !       }
  524. !       vduput(*((char *)tp->tty_phys));
  525.                   /* write 1 byte to terminal */
  526. !       tp->tty_phys++;        /* advance physical data pointer */
  527. !       tp->tty_cum++;        /* number of characters printed */
  528.     } while (--tp->tty_outleft != 0);
  529.     vducursor(1);
  530.     return(1);
  531. ***************
  532. *** 190,196 ****
  533. --- 194,204 ----
  534.       return;
  535.     case 012: /* LF */
  536.       if (mode & CRMOD)
  537. + #if 0
  538.           vduput('\r');
  539. + #else
  540. +             moveto(v->crow, 0);
  541. + #endif
  542.     case 013: /* VT */
  543.     case 014: /* FF */
  544.       if (v->crow == v->nrow - 1) {
  545. ***************
  546. *** 480,487 ****
  547. --- 488,499 ----
  548.     if (c >= '0' && c <= '9') {
  549.       i = 0;
  550.       do {
  551. + #if 0
  552.           i *= 10;
  553.           i += (c - '0');
  554. + #else
  555. +         i = (((i << 2) + i) << 1) + (c - '0');
  556. + #endif        
  557.           c = *v->next++;
  558.       } while (c >= '0' && c <= '9');
  559.     }
  560. ***************
  561. *** 508,519 ****
  562.     src = (long*)&v->vram[r1 * v->bytr];
  563.     dst = (long*)&v->vram[r2 * v->bytr];
  564.     i = v->bytr >> 4;    /* 16 bytes per iteration */
  565. !   while (--i >= 0) {
  566.       *dst++ = *src++;
  567.       *dst++ = *src++;
  568.       *dst++ = *src++;
  569.       *dst++ = *src++;
  570. !   }
  571.   }
  572.   
  573.   /*
  574. --- 520,531 ----
  575.     src = (long*)&v->vram[r1 * v->bytr];
  576.     dst = (long*)&v->vram[r2 * v->bytr];
  577.     i = v->bytr >> 4;    /* 16 bytes per iteration */
  578. !   do {
  579.       *dst++ = *src++;
  580.       *dst++ = *src++;
  581.       *dst++ = *src++;
  582.       *dst++ = *src++;
  583. !   } while(--i > 0);
  584.   }
  585.   
  586.   /*
  587. ***************
  588. *** 594,605 ****
  589.   
  590.     p = (long*)&v->vram[r * v->bytr];
  591.     i = v->bytr >> 4;    /* 16 bytes per iteration */
  592. !   while (--i >= 0) {
  593.       *p++ = 0L;
  594.       *p++ = 0L;
  595.       *p++ = 0L;
  596.       *p++ = 0L;
  597. !   }
  598.   }
  599.   
  600.   /*
  601. --- 606,617 ----
  602.   
  603.     p = (long*)&v->vram[r * v->bytr];
  604.     i = v->bytr >> 4;    /* 16 bytes per iteration */
  605. !   do {
  606.       *p++ = 0L;
  607.       *p++ = 0L;
  608.       *p++ = 0L;
  609.       *p++ = 0L;
  610. !   }   while (--i > 0) ;
  611.   }
  612.   
  613.   /*
  614. ***************
  615. *** 644,655 ****
  616. --- 656,699 ----
  617.   {
  618.     register struct vduinfo *v = &vduinfo;
  619.   
  620. + #ifdef NO_AUTOWRAP
  621.     if (r < 0 || r >= v->nrow || c < 0 || c > NCOL)
  622. + #else
  623. +   if (r < 0 || r >= v->nrow || c > NCOL)
  624. + #endif
  625.       return;
  626. + 
  627. + #ifndef NO_AUTOWRAP
  628. +   if (c < 0)        /* wrap backwards to previous line */
  629. +   {
  630. +       if(r == 0)
  631. +       moveto(0, 0);
  632. +       else
  633. +       moveto(r - 1, NCOL - 1);
  634. +       return;
  635. +   }
  636. + #endif
  637. +   
  638.     v->crow = r;
  639.     v->ccol = c;
  640.     if (c == NCOL)
  641. + #ifdef NO_AUTOWRAP
  642.       c--;            /* show cursor in last column */
  643. + #else
  644. +   {
  645. +     v->ccol = c = 0;        /* auto wrap */
  646. +     if(r == v->nrow - 1)
  647. +     {
  648. +     register int i;
  649. +     for (i = 0; i < r; i++)
  650. +         cpyline(i + 1, i);
  651. +     clrline(i);
  652. +     } else
  653. +     v->crow = ++r;
  654. +     v->curs = &v->vram[(r * v->bytr)];
  655. +     return;
  656. +   }
  657. + #endif
  658.   
  659.     if (!v->mono) {        /* 0->0, 1->1, 2->4, 3->5, 4->8, ... */
  660.       c <<= 1;
  661. *** /tmp/,RCSt1a27031    Thu Aug 24 00:02:11 1989
  662. --- stwini.c    Thu Aug 17 00:50:55 1989
  663. ***************
  664. *** 111,116 ****
  665. --- 111,119 ----
  666.   
  667.   /* Parameters for the disk drive. */
  668.   #define SECTOR_SIZE    512    /* physical sector size in bytes */
  669. + #define SECTOR_MASK    (SECTOR_SIZE - 1) /* mask for modulus */
  670. + #define SECTOR_SHIFT    9    /* 2^SECTOR_SHIFT == SECTOR_SIZE */
  671. + 
  672.   #define NR_DRIVES    8    /* maximum number of drives */
  673.   #define    MAX_MINOR    (NR_DRIVES<<3)
  674.   #define MAX_ERRORS    10    /* how often to try rd/wt before quitting */
  675. ***************
  676. *** 144,150 ****
  677.    *===========================================================================*/
  678.   PUBLIC void winchester_task()
  679.   {
  680. !   register    r, drive, minor, caller, procno;
  681.     long offset;    
  682.   
  683.    /*
  684. --- 147,154 ----
  685.    *===========================================================================*/
  686.   PUBLIC void winchester_task()
  687.   {
  688. !   register int    r, drive, minor, caller, procno;
  689. !   register struct pi *p;
  690.     long offset;    
  691.   
  692.    /*
  693. ***************
  694. *** 158,186 ****
  695.       minor = drive << 3;
  696.   
  697.   /* virtual drive 0 == physical drive */
  698.       /* read sector 0 of the drive and copy the partition info */
  699. !     pi[minor].pi_size = 1;
  700.       dmagrab(WINCHESTER, hdcint);
  701.       r = do_xfer(drive, (phys_bytes)&hi, 0L, 1, DISK_READ);
  702.       dmafree(WINCHESTER);
  703.       if (r != OK) {
  704. !         pi[minor].pi_size = 0;
  705.           continue;
  706.       }
  707. !     for (r = 0, minor++; r < NPARTS; r++, minor++) {
  708. !         pi[minor] = hi.hd_pi[r];
  709. !         if (pi[minor].pi_flag == PI_INVALID)
  710. !             pi[minor].pi_size = 0;
  711. !         if( pi[minor].pi_size )
  712. !             offset = pi[minor].pi_start + pi[minor].pi_size ;
  713.       }
  714.   /* partition 7 is the whole physical disk */
  715. !     pi[minor+2].pi_size = hi.hd_size;
  716.   #if HCJ_PARTITION
  717.   /* change partition 5 to be the whole physical disk */
  718.   /* but if a virtual drive is found, this is changed to the virtual size */
  719. !     pi[minor].pi_size = hi.hd_size;
  720. !     minor += 2;
  721.   
  722.       if(drive == 0 && pi[3].pi_size > 512) {
  723.           pi[3].pi_size -= 512;
  724. --- 162,191 ----
  725.       minor = drive << 3;
  726.   
  727.   /* virtual drive 0 == physical drive */
  728. + 
  729.       /* read sector 0 of the drive and copy the partition info */
  730. !     p = &pi[minor];
  731. !     p->pi_size = 1;
  732.       dmagrab(WINCHESTER, hdcint);
  733.       r = do_xfer(drive, (phys_bytes)&hi, 0L, 1, DISK_READ);
  734.       dmafree(WINCHESTER);
  735.       if (r != OK) {
  736. !         p->pi_size = 0;
  737.           continue;
  738.       }
  739. !     for (r = 0, p++; r < NPARTS; r++, p++) {
  740. !         *p = hi.hd_pi[r];
  741. !         if (p->pi_flag == PI_INVALID)
  742. !             p->pi_size = 0;
  743. !         if( p->pi_size )
  744. !             offset = p->pi_start + p->pi_size ;
  745.       }
  746.   /* partition 7 is the whole physical disk */
  747. !     (p+2)->pi_size = hi.hd_size;
  748.   #if HCJ_PARTITION
  749.   /* change partition 5 to be the whole physical disk */
  750.   /* but if a virtual drive is found, this is changed to the virtual size */
  751. !     p->pi_size = hi.hd_size;
  752.   
  753.       if(drive == 0 && pi[3].pi_size > 512) {
  754.           pi[3].pi_size -= 512;
  755. ***************
  756. *** 188,194 ****
  757.           pi[6].pi_start = pi[3].pi_start + pi[3].pi_size;
  758.       }
  759.   /* virtual drive 1 */
  760. !     minor = (drive+1) << 3;
  761.       if ( hi.bsl_start != 0L ) {
  762.   printf("Drive %d, virtual omitted: bsl_start=%lx offset=%lx \n",
  763.    DRIVE(drive),hi.bsl_start,offset);
  764. --- 193,199 ----
  765.           pi[6].pi_start = pi[3].pi_start + pi[3].pi_size;
  766.       }
  767.   /* virtual drive 1 */
  768. !     p = &pi[((drive+1) << 3)];
  769.       if ( hi.bsl_start != 0L ) {
  770.   printf("Drive %d, virtual omitted: bsl_start=%lx offset=%lx \n",
  771.    DRIVE(drive),hi.bsl_start,offset);
  772. ***************
  773. *** 197,220 ****
  774.       if(offset > hi.hd_size)
  775.           continue;
  776.       /* read sector 0 of the (virtual) drive and copy the partition info */
  777. !     pi[minor].pi_start = offset;
  778. !     pi[minor].pi_size = 1;
  779.       dmagrab(WINCHESTER, hdcint);
  780.       r = do_xfer(drive, (phys_bytes)&hi, offset, 1, DISK_READ);
  781.       dmafree(WINCHESTER);
  782.       if (r != OK) {
  783. !         pi[minor].pi_size = 0;
  784.           continue;
  785.       }
  786. !     for (r = 0, minor++; r < NPARTS; r++, minor++) {
  787. !         pi[minor] = hi.hd_pi[r];
  788. !         pi[minor].pi_start += offset;
  789. !         if (pi[minor].pi_flag == PI_INVALID)
  790. !             pi[minor].pi_size = 0;
  791.       }
  792.   /* set up partition 5 as whole virtual disk */
  793. !     pi[minor].pi_start = offset;
  794. !     pi[minor].pi_size = hi.hd_size - offset +1;
  795.   
  796.   /* change 'real' disk (virtural 0) to have only its own size in part. 5 */
  797.       pi[(drive<<3)+5].pi_size = offset;
  798. --- 202,225 ----
  799.       if(offset > hi.hd_size)
  800.           continue;
  801.       /* read sector 0 of the (virtual) drive and copy the partition info */
  802. !     p->pi_start = offset;
  803. !     p->pi_size = 1;
  804.       dmagrab(WINCHESTER, hdcint);
  805.       r = do_xfer(drive, (phys_bytes)&hi, offset, 1, DISK_READ);
  806.       dmafree(WINCHESTER);
  807.       if (r != OK) {
  808. !         p->pi_size = 0;
  809.           continue;
  810.       }
  811. !     for (r = 0, p++; r < NPARTS; r++, p++) {
  812. !         *p = hi.hd_pi[r];
  813. !         p->pi_start += offset;
  814. !         if (p->pi_flag == PI_INVALID)
  815. !             p->pi_size = 0;
  816.       }
  817.   /* set up partition 5 as whole virtual disk */
  818. !     p->pi_start = offset;
  819. !     p->pi_size = hi.hd_size - offset +1;
  820.   
  821.   /* change 'real' disk (virtural 0) to have only its own size in part. 5 */
  822.       pi[(drive<<3)+5].pi_size = offset;
  823. ***************
  824. *** 227,243 ****
  825.    * The next physical drive is hd16, with hd16-hd24, and hd24-hd31 
  826.    * the same as hd0-hd7 and hd8-hd15. Etc., for each addl drive.
  827.    */
  828. !     for (r = 0, minor=((drive+1) << 3); r < 8; r++, minor++) {
  829. !         pi[minor] = hi.hd_supra[r];
  830. !                 if (pi[minor].pi_flag == PI_INVALID)
  831. !             pi[minor].pi_size = 0;
  832.   /*
  833.    * HCJ: this is an added test of sanity:
  834.    * start and end of partition must be < hd_size 
  835.    */
  836. !         if (pi[minor].pi_start >= hi.hd_size || /* start is too big */
  837. !             pi[minor].pi_start + pi[minor].pi_size -1 >= hi.hd_size)
  838. !             pi[minor].pi_size = 0;
  839.       }
  840.   #endif
  841.                   
  842. --- 232,248 ----
  843.    * The next physical drive is hd16, with hd16-hd24, and hd24-hd31 
  844.    * the same as hd0-hd7 and hd8-hd15. Etc., for each addl drive.
  845.    */
  846. !     for (r = 0,p= &pi[((drive+1) << 3)]; r < 8; r++, p++) {
  847. !         *p = hi.hd_supra[r];
  848. !                 if (pi->pi_flag == PI_INVALID)
  849. !             p->pi_size = 0;
  850.   /*
  851.    * HCJ: this is an added test of sanity:
  852.    * start and end of partition must be < hd_size 
  853.    */
  854. !         if (p->pi_start >= hi.hd_size || /* start is too big */
  855. !             p->pi_start + p->pi_size -1 >= hi.hd_size)
  856. !             p->pi_size = 0;
  857.       }
  858.   #endif
  859.                   
  860. ***************
  861. *** 292,298 ****
  862.   register message *mp;
  863.   {
  864.     register struct proc    *rp;
  865. !   register        r, errors, count, rw, drive, minor;
  866.     register long        secnum;
  867.     register phys_bytes    address;
  868.     extern phys_bytes    umap(struct proc *, int, long, long);
  869. --- 297,304 ----
  870.   register message *mp;
  871.   {
  872.     register struct proc    *rp;
  873. !   register int        r, errors, count, rw, drive, minor;
  874. !   register struct pi    *p;
  875.     register long        secnum;
  876.     register phys_bytes    address;
  877.     extern phys_bytes    umap(struct proc *, int, long, long);
  878. ***************
  879. *** 302,327 ****
  880.     drive = minor >> 3;
  881.     if (drive < 0 || drive >= NR_DRIVES)
  882.       return(EIO);
  883. !   if (pi[minor].pi_size == 0)
  884.       return(EIO);
  885. !   if ((mp->POSITION % SECTOR_SIZE) != 0)
  886.       return(EINVAL);
  887. !   secnum = (long)(mp->POSITION / SECTOR_SIZE);
  888.     count = mp->COUNT;
  889. !   if ((count % SECTOR_SIZE) != 0)
  890.       return(EINVAL);
  891.     rp = proc_addr(mp->PROC_NR);
  892.     address = umap(rp, D, (vir_bytes) mp->ADDRESS, (vir_bytes) count);
  893.     if (address == 0)
  894.       return(EINVAL);
  895. !   count /= SECTOR_SIZE;
  896.     TRACE(printf("hd%d: %s: sec=%D; cnt=%d\n",
  897.       minor, rw == DISK_READ ? "read" : "write", secnum, count));
  898. !   if (pi[minor].pi_size - secnum < count)
  899. !     count = pi[minor].pi_size - secnum;
  900.     if (count <= 0)
  901.       return(EOF);
  902. !   secnum += pi[minor].pi_start;
  903.     rp->p_physio = 1;        /* disable (un)shadowing */
  904.     dmagrab(WINCHESTER, hdcint);
  905.     /* This loop allows a failed operation to be repeated. */
  906. --- 308,335 ----
  907.     drive = minor >> 3;
  908.     if (drive < 0 || drive >= NR_DRIVES)
  909.       return(EIO);
  910. ! 
  911. !   p = &pi[minor];
  912. !   if (p->pi_size == 0)
  913.       return(EIO);
  914. !   if ((mp->POSITION & SECTOR_MASK) != 0)
  915.       return(EINVAL);
  916. !   secnum = (long)(mp->POSITION >> SECTOR_SHIFT);
  917.     count = mp->COUNT;
  918. !   if ((count & SECTOR_MASK) != 0)
  919.       return(EINVAL);
  920.     rp = proc_addr(mp->PROC_NR);
  921.     address = umap(rp, D, (vir_bytes) mp->ADDRESS, (vir_bytes) count);
  922.     if (address == 0)
  923.       return(EINVAL);
  924. !   count >>= SECTOR_SHIFT;
  925.     TRACE(printf("hd%d: %s: sec=%D; cnt=%d\n",
  926.       minor, rw == DISK_READ ? "read" : "write", secnum, count));
  927. !   if (p->pi_size - secnum < count)
  928. !     count = p->pi_size - secnum;
  929.     if (count <= 0)
  930.       return(EOF);
  931. !   secnum += p->pi_start;
  932.     rp->p_physio = 1;        /* disable (un)shadowing */
  933.     dmagrab(WINCHESTER, hdcint);
  934.     /* This loop allows a failed operation to be repeated. */
  935. ***************
  936. *** 334,340 ****
  937.     rp->p_physio = 0;        /* enable (un)shadowing */
  938.     if (r != OK)
  939.       return(EIO);
  940. !   return(count * SECTOR_SIZE);
  941.   }
  942.   
  943.   
  944. --- 342,348 ----
  945.     rp->p_physio = 0;        /* enable (un)shadowing */
  946.     if (r != OK)
  947.       return(EIO);
  948. !   return(count << SECTOR_SHIFT);
  949.   }
  950.   
  951.   
  952. *** /tmp/,RCSt1a27031    Thu Aug 24 00:02:14 1989
  953. --- system.c    Thu Aug 17 02:06:43 1989
  954. ***************
  955. *** 761,767 ****
  956.   }
  957.   
  958.   #ifdef ATARI_ST
  959. ! #if 0
  960.   /*===========================================================================*
  961.    *                phys_copy                     * 
  962.    *===========================================================================*/
  963. --- 761,767 ----
  964.   }
  965.   
  966.   #ifdef ATARI_ST
  967. ! #if 0 /* see copy68k.cpp */
  968.   /*===========================================================================*
  969.    *                phys_copy                     * 
  970.    *===========================================================================*/
  971. ***************
  972. *** 807,813 ****
  973.     }
  974.   }
  975.   
  976. ! #endif
  977.   
  978.   /*===========================================================================*
  979.    *                build_sig                     * 
  980. --- 807,813 ----
  981.     }
  982.   }
  983.   
  984. ! #endif /* see copy68k.cpp */
  985.   
  986.   /*===========================================================================*
  987.    *                build_sig                     * 
  988.