Removed NIL_SYS_PROC and NIL_PROC

- NIL_PROC replaced by simple NULLs

diff --git a/kernel/clock.c b/kernel/clock.c
index d42560180509e4c0c9983049219e9f7525e6631f..950dadce66a13145eefa63b075cb1eebbfef7dba 100644 (file)
--- a/kernel/clock.c
+++ b/kernel/clock.c
@@ -162,7 +162,7 @@ PRIVATE void load_update(void)
 
        /* Cumulation. How many processes are ready now? */
        for(q = 0; q < NR_SCHED_QUEUES; q++)
-               for(p = rdy_head[q]; p != NIL_PROC; p = p->p_nextready)
+               for(p = rdy_head[q]; p; p = p->p_nextready)
                        enqueued++;
 
        kloadinfo.proc_load_history[slot] += enqueued;

diff --git a/kernel/debug.c b/kernel/debug.c
index 9fc79255f8336576a82c1ed12f09f4d0ad327972..32cc0f2ad912f05e8aabfc4eb77a7df1ce438284 100644 (file)
--- a/kernel/debug.c
+++ b/kernel/debug.c
@@ -33,11 +33,11 @@ runqueues_ok(void)
        printf("tail but no head in %d\n", q);
        return 0;
     }
-    if (rdy_tail[q] && rdy_tail[q]->p_nextready != NIL_PROC) {
+    if (rdy_tail[q] && rdy_tail[q]->p_nextready) {
        printf("tail and tail->next not null in %d\n", q);
        return 0;
     }
-    for(xp = rdy_head[q]; xp != NIL_PROC; xp = xp->p_nextready) {
+    for(xp = rdy_head[q]; xp; xp = xp->p_nextready) {
        const vir_bytes vxp = (vir_bytes) xp;
        vir_bytes dxp;
        if(vxp < (vir_bytes) BEG_PROC_ADDR || vxp >= (vir_bytes) END_PROC_ADDR) {
@@ -74,7 +74,7 @@ runqueues_ok(void)
                return 0;
        }
        xp->p_found = 1;
-       if (xp->p_nextready == NIL_PROC && rdy_tail[q] != xp) {
+       if (!xp->p_nextready && rdy_tail[q] != xp) {
                printf("sched err: last element not tail q %d proc %d\n",
                        q, xp->p_nr);
                return 0;

diff --git a/kernel/proc.c b/kernel/proc.c
index 208f8268aa84ea5da8f330a3dd308723c41888a8..361dd05ca2f305ff7c3e6a9d991b2fcacebbdc3b 100644 (file)
--- a/kernel/proc.c
+++ b/kernel/proc.c
@@ -595,9 +595,9 @@ const int flags;
 
        /* Process is now blocked.  Put in on the destination's queue. */
        xpp = &dst_ptr->p_caller_q;             /* find end of list */
-       while (*xpp != NIL_PROC) xpp = &(*xpp)->p_q_link;       
+       while (*xpp) xpp = &(*xpp)->p_q_link;   
        *xpp = caller_ptr;                      /* add caller to end */
-       caller_ptr->p_q_link = NIL_PROC;        /* mark new end of list */
+       caller_ptr->p_q_link = NULL;    /* mark new end of list */
   }
   return(OK);
 }
@@ -700,7 +700,7 @@ const int flags;
 
     /* Check caller queue. Use pointer pointers to keep code simple. */
     xpp = &caller_ptr->p_caller_q;
-    while (*xpp != NIL_PROC) {
+    while (*xpp) {
         if (src_e == ANY || src_p == proc_nr(*xpp)) {
             int call;
            assert(!RTS_ISSET(*xpp, RTS_SLOT_FREE));
@@ -1156,9 +1156,9 @@ PUBLIC void enqueue(
   assert(q >= 0);
 
   /* Now add the process to the queue. */
-  if (rdy_head[q] == NIL_PROC) {               /* add to empty queue */
+  if (!rdy_head[q]) {          /* add to empty queue */
       rdy_head[q] = rdy_tail[q] = rp;          /* create a new queue */
-      rp->p_nextready = NIL_PROC;              /* mark new end */
+      rp->p_nextready = NULL;          /* mark new end */
   } 
   else if (front) {                            /* add to head of queue */
       rp->p_nextready = rdy_head[q];           /* chain head of queue */
@@ -1167,7 +1167,7 @@ PUBLIC void enqueue(
   else {                                       /* add to tail of queue */
       rdy_tail[q]->p_nextready = rp;           /* chain tail of queue */       
       rdy_tail[q] = rp;                                /* set new queue tail */
-      rp->p_nextready = NIL_PROC;              /* mark new end */
+      rp->p_nextready = NULL;          /* mark new end */
   }
 
   /*
@@ -1215,9 +1215,9 @@ PRIVATE void enqueue_head(struct proc *rp)
 
 
   /* Now add the process to the queue. */
-  if (rdy_head[q] == NIL_PROC) {               /* add to empty queue */
+  if (!rdy_head[q]) {          /* add to empty queue */
       rdy_head[q] = rdy_tail[q] = rp;          /* create a new queue */
-      rp->p_nextready = NIL_PROC;              /* mark new end */
+      rp->p_nextready = NULL;          /* mark new end */
   }
   else                                         /* add to head of queue */
       rp->p_nextready = rdy_head[q];           /* chain head of queue */
@@ -1254,8 +1254,8 @@ PUBLIC void dequeue(const struct proc *rp)
    * process if it is found. A process can be made unready even if it is not 
    * running by being sent a signal that kills it.
    */
-  prev_xp = NIL_PROC;                          
-  for (xpp = &rdy_head[q]; *xpp != NIL_PROC; xpp = &(*xpp)->p_nextready) {
+  prev_xp = NULL;                              
+  for (xpp = &rdy_head[q]; *xpp; xpp = &(*xpp)->p_nextready) {
       if (*xpp == rp) {                                /* found process to remove */
           *xpp = (*xpp)->p_nextready;          /* replace with next chain */
           if (rp == rdy_tail[q]) {             /* queue tail removed */

diff --git a/kernel/proc.h b/kernel/proc.h
index df7262bb7a4ade917b2cbcef45b5633c3b9b4c93..ee37a218ccd339f7eabd599e3bdca1ae2a13c040 100644 (file)
--- a/kernel/proc.h
+++ b/kernel/proc.h
@@ -240,8 +240,6 @@ struct proc {
 #define BEG_USER_ADDR (&proc[NR_TASKS])
 #define END_PROC_ADDR (&proc[NR_TASKS + NR_PROCS])
 
-#define NIL_PROC          ((struct proc *) 0)          
-#define NIL_SYS_PROC      ((struct proc *) 1)          
 #define cproc_addr(n)     (&(proc + NR_TASKS)[(n)])
 #define proc_addr(n)      (&(proc[NR_TASKS + (n)]))
 #define proc_nr(p)       ((p)->p_nr)

diff --git a/kernel/system.c b/kernel/system.c
index 49e2f08f011f954653b5ccc590ce83377b5a4629..2535022b4bc9c94fb22e007b54e4445d37486f4e 100644 (file)
--- a/kernel/system.c
+++ b/kernel/system.c
@@ -512,7 +512,7 @@ register struct proc *rc;           /* slot of process to clean up */
 
       okendpt(rc->p_sendto_e, &target_proc);
       xpp = &proc_addr(target_proc)->p_caller_q; /* destination's queue */
-      while (*xpp != NIL_PROC) {               /* check entire queue */
+      while (*xpp) {           /* check entire queue */
           if (*xpp == rc) {                    /* process is on the queue */
               *xpp = (*xpp)->p_q_link;         /* replace by next process */
 #if DEBUG_ENABLE_IPC_WARNINGS