diff -Naur a/top.c b/top.c
--- a/top.c	2007-05-28 09:04:00.000000000 -0700
+++ b/top.c	2014-09-04 13:24:59.862877761 -0700
@@ -184,19 +184,19 @@
          * 2 columns each.
          */
 
-SCB_NUMx(P_PID, XXXID)
-SCB_NUMx(P_PPD, ppid)
-SCB_STRx(P_URR, ruser)
-SCB_NUMx(P_UID, euid)
-SCB_STRx(P_URE, euser)
-SCB_STRx(P_GRP, egroup)
-SCB_NUMx(P_TTY, tty)
-SCB_NUMx(P_PRI, priority)
-SCB_NUMx(P_NCE, nice)
-SCB_NUMx(P_CPN, processor)
-SCB_NUM1(P_CPU, pcpu)
-                                        // also serves P_TM2 !
-static int sort_P_TME (const proc_t **P, const proc_t **Q)
+SCB_NUMx(EU_PID, XXXID)
+SCB_NUMx(EU_PPD, ppid)
+SCB_STRx(EU_URR, ruser)
+SCB_NUMx(EU_UID, euid)
+SCB_STRx(EU_URE, euser)
+SCB_STRx(EU_GRP, egroup)
+SCB_NUMx(EU_TTY, tty)
+SCB_NUMx(EU_PRI, priority)
+SCB_NUMx(EU_NCE, nice)
+SCB_NUMx(EU_CPN, processor)
+SCB_NUM1(EU_CPU, pcpu)
+                                        // also serves EU_TM2 !
+static int sort_EU_TME (const proc_t **P, const proc_t **Q)
 {
    if (Frame_ctimes) {
       if ( ((*P)->cutime + (*P)->cstime + (*P)->utime + (*P)->stime)
@@ -214,17 +214,17 @@
    return SORT_eq;
 }
 
-SCB_NUM1(P_VRT, size)
-SCB_NUM2(P_SWP, size, resident)
-SCB_NUM1(P_RES, resident)               // also serves P_MEM !
-SCB_NUM1(P_COD, trs)
-SCB_NUM1(P_DAT, drs)
-SCB_NUM1(P_SHR, share)
-SCB_NUM1(P_FLT, maj_flt)
-SCB_NUM1(P_DRT, dt)
-SCB_NUMx(P_STA, state)
+SCB_NUM1(EU_VRT, size)
+SCB_NUM2(EU_SWP, size, resident)
+SCB_NUM1(EU_RES, resident)               // also serves EU_MEM !
+SCB_NUM1(EU_COD, trs)
+SCB_NUM1(EU_DAT, drs)
+SCB_NUM1(EU_SHR, share)
+SCB_NUM1(EU_FLT, maj_flt)
+SCB_NUM1(EU_DRT, dt)
+SCB_NUMx(EU_STA, state)
 
-static int sort_P_CMD (const proc_t **P, const proc_t **Q)
+static int sort_EU_CMD (const proc_t **P, const proc_t **Q)
 {
    /* if a process doesn't have a cmdline, we'll consider it a kernel thread
       -- since displayed tasks are given special treatment, we must too */
@@ -238,8 +238,8 @@
    return Frame_srtflg * strcmp((*Q)->cmd, (*P)->cmd);
 }
 
-SCB_NUM1(P_WCH, wchan)
-SCB_NUM1(P_FLG, flags)
+SCB_NUM1(EU_WCH, wchan)
+SCB_NUM1(EU_FLG, flags)
 
         /* ///////////////////////////////// special sort for prochlp() ! */
 static int sort_HST_t (const HST_t *P, const HST_t *Q)
@@ -562,7 +562,7 @@
 
 // Show an error, but not right now.
 // Due to the postponed opening of ksym, using open_psdb_message,
-// if P_WCH had been selected and the program is restarted, the
+// if EU_WCH had been selected and the program is restarted, the
 // message would otherwise be displayed prematurely.
 static void msg_save (const char *fmts, ...) __attribute__((format(printf,1,2)));
 static void msg_save (const char *fmts, ...)
@@ -1213,7 +1213,7 @@
 #define L_DEFAULT  PROC_FILLSTAT
 
 // a temporary macro, soon to be undef'd...
-#define SF(f) (QFP_t)sort_P_ ## f
+#define SF(f) (QFP_t)sort_EU_ ## f
 
         /* These are our gosh darn 'Fields' !
            They MUST be kept in sync with pflags !!
@@ -1222,9 +1222,9 @@
                  a cast when/if displayed provides minimal width protection. */
 static FLD_t Fieldstab[] = {
 /* .lflg anomolies:
-      P_UID, L_NONE  - natural outgrowth of 'stat()' in readproc        (euid)
-      P_CPU, L_stat  - never filled by libproc, but requires times      (pcpu)
-      P_CMD, L_stat  - may yet require L_CMDLINE in reframewins  (cmd/cmdline)
+      EU_UID, L_NONE  - natural outgrowth of 'stat()' in readproc        (euid)
+      EU_CPU, L_stat  - never filled by libproc, but requires times      (pcpu)
+      EU_CMD, L_stat  - may yet require L_CMDLINE in reframewins  (cmd/cmdline)
       L_EITHER       - must L_status, else 64-bit math, __udivdi3 on 32-bit !
       keys   head           fmts     width   scale  sort   desc                     lflg
      ------  -----------    -------  ------  -----  -----  ----------------------   -------- */
@@ -1514,23 +1514,23 @@
 
          case 'M':
             c = 0; // for scoreboard
-            rc->win[0].sortindx = P_MEM;
+            rc->win[0].sortindx = EU_MEM;
             break;
          case 'P':
             c = 0; // for scoreboard
-            rc->win[0].sortindx = P_CPU;
+            rc->win[0].sortindx = EU_CPU;
             break;
          case 'A':                      // supposed to be start_time
             c = 0; // for scoreboard
-            rc->win[0].sortindx = P_PID;
+            rc->win[0].sortindx = EU_PID;
             break;
          case 'T':
             c = 0; // for scoreboard
-            rc->win[0].sortindx = P_TM2;
+            rc->win[0].sortindx = EU_TM2;
             break;
          case 'N':
             c = 0; // for scoreboard
-            rc->win[0].sortindx = P_PID;
+            rc->win[0].sortindx = EU_PID;
             break;
 
          default:
@@ -1626,19 +1626,19 @@
 
    pcpu_max_value = 99.9;
 
-   Fieldstab[P_CPN].head = " P";
-   Fieldstab[P_CPN].fmts = " %1u";
+   Fieldstab[EU_CPN].head = " P";
+   Fieldstab[EU_CPN].fmts = " %1u";
    if(smp_num_cpus>9){
-      Fieldstab[P_CPN].head = "  P";
-      Fieldstab[P_CPN].fmts = " %2u";
+      Fieldstab[EU_CPN].head = "  P";
+      Fieldstab[EU_CPN].fmts = " %2u";
    }
    if(smp_num_cpus>99){
-      Fieldstab[P_CPN].head = "   P";
-      Fieldstab[P_CPN].fmts = " %3u";
+      Fieldstab[EU_CPN].head = "   P";
+      Fieldstab[EU_CPN].fmts = " %3u";
    }
    if(smp_num_cpus>999){
-      Fieldstab[P_CPN].head = "    P";
-      Fieldstab[P_CPN].fmts = " %4u";
+      Fieldstab[EU_CPN].head = "    P";
+      Fieldstab[EU_CPN].fmts = " %4u";
    }
 
    {
@@ -1646,10 +1646,10 @@
       unsigned pid_digits = get_pid_digits();
       if(pid_digits<4) pid_digits=4;
       snprintf(pid_fmt, sizeof pid_fmt, " %%%uu", pid_digits);
-      Fieldstab[P_PID].fmts = pid_fmt;
-      Fieldstab[P_PID].head = "        PID" + 10 - pid_digits;
-      Fieldstab[P_PPD].fmts = pid_fmt;
-      Fieldstab[P_PPD].head = "       PPID" + 10 - pid_digits;
+      Fieldstab[EU_PID].fmts = pid_fmt;
+      Fieldstab[EU_PID].head = "        PID" + 10 - pid_digits;
+      Fieldstab[EU_PPD].fmts = pid_fmt;
+      Fieldstab[EU_PPD].head = "       PPID" + 10 - pid_digits;
    }
 }
 
@@ -1786,7 +1786,7 @@
    if(Rc.mode_irixps && smp_num_cpus>1){
       // good for 100 CPUs per process
       pcpu_max_value = 9999.0;
-      Fieldstab[P_CPU].fmts = " %4.0f";
+      Fieldstab[EU_CPU].fmts = " %4.0f";
    }
 
    // lastly, establish the true runtime secure mode and delay time
@@ -2135,13 +2135,13 @@
          }
 
          // establish the final maxpflgs and prepare to grow the command column
-         // heading via maxcmdln - it may be a fib if P_CMD wasn't encountered,
+         // heading via maxcmdln - it may be a fib if EU_CMD wasn't encountered,
          // but that's ok because it won't be displayed anyway
          w->maxpflgs = i;
-         w->maxcmdln = Screen_cols - (strlen(w->columnhdr) - strlen(Fieldstab[P_CMD].head));
+         w->maxcmdln = Screen_cols - (strlen(w->columnhdr) - strlen(Fieldstab[EU_CMD].head));
 
          // finally, we can build the true run-time columns header, format the
-         // command column heading, if P_CMD is really being displayed, and
+         // command column heading, if EU_CMD is really being displayed, and
          // rebuild the all-important PROC_FILLxxx flags that will be used
          // until/if we're we're called again
          *(s = w->columnhdr) = '\0';
@@ -2149,9 +2149,9 @@
          for (i = 0; i < w->maxpflgs; i++) {
             int advance = (i==0) && !Rc.mode_altscr;
             h = Fieldstab[w->procflags[i]].head;
-            if (P_WCH == w->procflags[i]) needpsdb = 1;
-            if (P_CMD == w->procflags[i]) {
-               s = scat(s, fmtmk(Fieldstab[P_CMD].fmts+advance, w->maxcmdln, w->maxcmdln, "COMMAND"/*h*/  ));
+            if (EU_WCH == w->procflags[i]) needpsdb = 1;
+            if (EU_CMD == w->procflags[i]) {
+               s = scat(s, fmtmk(Fieldstab[EU_CMD].fmts+advance, w->maxcmdln, w->maxcmdln, "COMMAND"/*h*/  ));
                if (CHKw(w, Show_CMDLIN)) {
                   Frames_libflags |= L_CMDLINE;
 //                if (w->maxcmdln > Frames_maxcmdln) Frames_maxcmdln = w->maxcmdln;
@@ -2629,10 +2629,10 @@
          if(Rc.mode_irixps && smp_num_cpus>1){
             // good for 100 CPUs per process
             pcpu_max_value = 9999.0;
-            Fieldstab[P_CPU].fmts = " %4.0f";
+            Fieldstab[EU_CPU].fmts = " %4.0f";
          } else {
             pcpu_max_value = 99.9;
-            Fieldstab[P_CPU].fmts = " %#4.1f";
+            Fieldstab[EU_CPU].fmts = " %#4.1f";
          }
          break;
 
@@ -2836,8 +2836,8 @@
             const unsigned  xkey;
             const FLG_t     sort;
          } xtab[] = {
-            { "Memory", 'M', P_MEM, }, { "Numerical", 'N', P_PID, },
-            { "CPU",    'P', P_CPU, }, { "Time",      'T', P_TM2  }, };
+            { "Memory", 'M', EU_MEM, }, { "Numerical", 'N', EU_PID, },
+            { "CPU",    'P', EU_CPU, }, { "Time",      'T', EU_TM2  }, };
          int i;
          for (i = 0; i < MAXTBL(xtab); ++i)
             if (c == xtab[i].xkey) {
@@ -3063,7 +3063,7 @@
       int advance = (x==0) && !Rc.mode_altscr;
 
       switch (i) {
-         case P_CMD:
+         case EU_CMD:
          {  char tmp[ROWBUFSIZ];
             unsigned flags;
 	    int maxcmd = q->maxcmdln;
@@ -3073,25 +3073,25 @@
             MKCOL(q->maxcmdln, q->maxcmdln, tmp);
          }
             break;
-         case P_COD:
+         case EU_COD:
             MKCOL(scale_num(PAGES_TO_KB(p->trs), w, s));
             break;
-         case P_CPN:
+         case EU_CPN:
             MKCOL((unsigned)p->processor);
             break;
-         case P_CPU:
+         case EU_CPU:
          {  float u = (float)p->pcpu * Frame_tscale;
             if (u > pcpu_max_value) u = pcpu_max_value;
             MKCOL(u);
          }
             break;
-         case P_DAT:
+         case EU_DAT:
             MKCOL(scale_num(PAGES_TO_KB(p->drs), w, s));
             break;
-         case P_DRT:
+         case EU_DRT:
             MKCOL(scale_num((unsigned)p->dt, w, s));
             break;
-         case P_FLG:
+         case EU_FLG:
          {  char tmp[TNYBUFSIZ];
             snprintf(tmp, sizeof(tmp), f, (long)p->flags);
             for (j = 0; tmp[j]; j++) if ('0' == tmp[j]) tmp[j] = '.';
@@ -3099,70 +3099,70 @@
             MKCOL("");
          }
             break;
-         case P_FLT:
+         case EU_FLT:
             MKCOL(scale_num(p->maj_flt, w, s));
             break;
-         case P_GRP:
+         case EU_GRP:
             MKCOL(p->egroup);
             break;
-         case P_MEM:
+         case EU_MEM:
             MKCOL((float)PAGES_TO_KB(p->resident) * 100 / kb_main_total);
             break;
-         case P_NCE:
+         case EU_NCE:
             MKCOL((int)p->nice);
             break;
-         case P_PID:
+         case EU_PID:
             MKCOL((unsigned)p->XXXID);
             break;
-         case P_PPD:
+         case EU_PPD:
             MKCOL((unsigned)p->ppid);
             break;
-         case P_PRI:
+         case EU_PRI:
             if (unlikely(-99 > p->priority) || unlikely(999 < p->priority)) {
                f = "  RT";
                MKCOL("");
             } else
                MKCOL((int)p->priority);
             break;
-         case P_RES:
+         case EU_RES:
             MKCOL(scale_num(PAGES_TO_KB(p->resident), w, s));
             break;
-         case P_SHR:
+         case EU_SHR:
             MKCOL(scale_num(PAGES_TO_KB(p->share), w, s));
             break;
-         case P_STA:
+         case EU_STA:
             MKCOL(p->state);
             break;
-         case P_SWP:
+         case EU_SWP:
             MKCOL(scale_num(PAGES_TO_KB(p->size - p->resident), w, s));
             break;
-         case P_TME:
-         case P_TM2:
+         case EU_TME:
+         case EU_TM2:
          {  TIC_t t = p->utime + p->stime;
             if (CHKw(q, Show_CTIMES))
                t += (p->cutime + p->cstime);
             MKCOL(scale_tics(t, w));
          }
             break;
-         case P_TTY:
+         case EU_TTY:
          {  char tmp[TNYBUFSIZ];
             dev_to_tty(tmp, (int)w, p->tty, p->XXXID, ABBREV_DEV);
             MKCOL(tmp);
          }
             break;
-         case P_UID:
+         case EU_UID:
             MKCOL((unsigned)p->euid);
             break;
-         case P_URE:
+         case EU_URE:
             MKCOL(p->euser);
             break;
-         case P_URR:
+         case EU_URR:
             MKCOL(p->ruser);
             break;
-         case P_VRT:
+         case EU_VRT:
             MKCOL(scale_num(PAGES_TO_KB(p->size), w, s));
             break;
-         case P_WCH:
+         case EU_WCH:
             if (No_ksyms) {
                f = " %08lx ";
                MKCOL((long)p->wchan);
diff -Naur a/top.h b/top.h
--- a/top.h	2006-06-24 23:41:48.000000000 -0700
+++ b/top.h	2014-09-04 13:14:40.124239420 -0700
@@ -245,12 +245,12 @@
 
 // Flags for each possible field
 enum pflag {
-   P_PID, P_PPD, P_URR, P_UID, P_URE, P_GRP, P_TTY,
-   P_PRI, P_NCE,
-   P_CPN, P_CPU, P_TME, P_TM2,
-   P_MEM, P_VRT, P_SWP, P_RES, P_COD, P_DAT, P_SHR,
-   P_FLT, P_DRT,
-   P_STA, P_CMD, P_WCH, P_FLG
+   EU_PID, EU_PPD, EU_URR, EU_UID, EU_URE, EU_GRP, EU_TTY,
+   EU_PRI, EU_NCE,
+   EU_CPN, EU_CPU, EU_TME, EU_TM2,
+   EU_MEM, EU_VRT, EU_SWP, EU_RES, EU_COD, EU_DAT, EU_SHR,
+   EU_FLT, EU_DRT,
+   EU_STA, EU_CMD, EU_WCH, EU_FLG
 };
 
 
@@ -362,16 +362,16 @@
 // The default values for the local config file
 #define DEF_RCFILE { \
    0, 1, DEF_DELAY, 0, { \
-   { P_CPU, DEF_WINFLGS, 0, \
+   { EU_CPU, DEF_WINFLGS, 0, \
       COLOR_RED, COLOR_RED, COLOR_YELLOW, COLOR_RED, \
       "Def", DEF_FIELDS }, \
-   { P_PID, DEF_WINFLGS, 0, \
+   { EU_PID, DEF_WINFLGS, 0, \
       COLOR_CYAN, COLOR_CYAN, COLOR_WHITE, COLOR_CYAN, \
       "Job", JOB_FIELDS }, \
-   { P_MEM, DEF_WINFLGS, 0, \
+   { EU_MEM, DEF_WINFLGS, 0, \
       COLOR_MAGENTA, COLOR_MAGENTA, COLOR_BLUE, COLOR_MAGENTA, \
       "Mem", MEM_FIELDS }, \
-   { P_URE, DEF_WINFLGS, 0, \
+   { EU_URE, DEF_WINFLGS, 0, \
       COLOR_YELLOW, COLOR_YELLOW, COLOR_GREEN, COLOR_YELLOW, \
       "Usr", USR_FIELDS } \
    } }