diff --git a/PDP18B/pdp18b_cpu.c b/PDP18B/pdp18b_cpu.c
index 98962378..92d0833c 100644
--- a/PDP18B/pdp18b_cpu.c
+++ b/PDP18B/pdp18b_cpu.c
@@ -457,69 +457,69 @@ UNIT cpu_unit = {
     };
 
 REG cpu_reg[] = {
-    { ORDATA (PC, PC, ADDRSIZE) },
-    { ORDATA (AC, LAC, 18) },
-    { FLDATA (L, LAC, 18) },
-    { ORDATA (MQ, MQ, 18) },
-    { ORDATA (SC, SC, 6) },
-    { FLDATA (EAE_AC_SIGN, eae_ac_sign, 18) },
-    { ORDATA (SR, SR, 18) },
-    { ORDATA (ASW, ASW, ADDRSIZE) },
-    { ORDATA (IORS, iors, 18), REG_RO },
-    { BRDATA (INT, int_hwre, 8, 32, API_HLVL+1), REG_RO },
-    { FLDATA (INT_PEND, int_pend, 0), REG_RO },
-    { FLDATA (ION, ion, 0) },
-    { ORDATA (ION_DELAY, ion_defer, 2) },
+    { ORDATAD (PC, PC, ADDRSIZE, "program counter") },
+    { ORDATAD (AC, LAC, 18, "accumulator") },
+    { FLDATAD (L, LAC, 18, "link") },
+    { ORDATAD (MQ, MQ, 18, "multiplier-quotient") },
+    { ORDATAD (SC, SC, 6, "shift counter") },
+    { FLDATAD (EAE_AC_SIGN, eae_ac_sign, 18, "EAE AC sign") },
+    { ORDATAD (SR, SR, 18, "front panel switches") },
+    { ORDATAD (ASW, ASW, ADDRSIZE, "address switches for RIM load") },
+    { ORDATAD (IORS, iors, 18, "IORS register"), REG_RO },
+    { BRDATAD (INT, int_hwre, 8, 32, API_HLVL+1, "interrupt requests, 0:3 = API levels 0 to 3,                                    4 = PI level"), REG_RO },
+    { FLDATAD (INT_PEND, int_pend, 0, "interrupt pending"), REG_RO },
+    { FLDATAD (ION, ion, 0, "interrupt enable") },
+    { ORDATAD (ION_DELAY, ion_defer, 2, "interrupt enable delay") },
 #if defined (PDP7) 
-    { FLDATA (TRAPM, usmd, 0) },
-    { FLDATA (TRAPP, trap_pending, 0) },
-    { FLDATA (EXTM, memm, 0) },
-    { FLDATA (EXTM_INIT, memm_init, 0) },
-    { FLDATA (EMIRP, emir_pending, 0) },
+    { FLDATAD (TRAPM, usmd, 0, "trap mode") },
+    { FLDATAD (TRAPP, trap_pending, 0, "trap pending") },
+    { FLDATAD (EXTM, memm, 0, "extend mode") },
+    { FLDATAD (EXTM_INIT, memm_init, 0, "exit mode value after reset") },
+    { FLDATAD (EMIRP, emir_pending, 0, "EMIR instruction pending") },
 #endif
 #if defined (PDP9)
-    { FLDATA (APIENB, api_enb, 0) },
-    { ORDATA (APIREQ, api_req, 8) },
-    { ORDATA (APIACT, api_act, 8) },
-    { ORDATA (BR, BR, ADDRSIZE) },
-    { FLDATA (USMD, usmd, 0) },
-    { FLDATA (USMDBUF, usmd_buf, 0) },
-    { FLDATA (USMDDEF, usmd_defer, 0) },
-    { FLDATA (NEXM, nexm, 0) },
-    { FLDATA (PRVN, prvn, 0) },
-    { FLDATA (TRAPP, trap_pending, 0) },
-    { FLDATA (EXTM, memm, 0) },
-    { FLDATA (EXTM_INIT, memm_init, 0) },
-    { FLDATA (EMIRP, emir_pending, 0) },
-    { FLDATA (RESTP, rest_pending, 0) },
-    { FLDATA (PWRFL, int_hwre[API_PWRFL], INT_V_PWRFL) },
+    { FLDATAD (APIENB, api_enb, 0, "api enable") },
+    { ORDATAD (APIREQ, api_req, 8, "api requesting levels") },
+    { ORDATAD (APIACT, api_act, 8, "api active levels") },
+    { ORDATAD (BR, BR, ADDRSIZE, "memory protection bounds") },
+    { FLDATAD (USMD, usmd, 0, "user mode") },
+    { FLDATAD (USMDBUF, usmd_buf, 0, "user mode buffer") },
+    { FLDATAD (USMDDEF, usmd_defer, 0, "user mode load defer") },
+    { FLDATAD (NEXM, nexm, 0, "non-existent memory violation") },
+    { FLDATAD (PRVN, prvn, 0, "privilege violation") },
+    { FLDATAD (TRAPP, trap_pending, 0, "trap pending") },
+    { FLDATAD (EXTM, memm, 0, "extend mode") },
+    { FLDATAD (EXTM_INIT, memm_init, 0, "extend mode value after reset") },
+    { FLDATAD (EMIRP, emir_pending, 0, "EMIR instruction pending") },
+    { FLDATAD (RESTP, rest_pending, 0, "DBR or RES instruction pending") },
+    { FLDATAD (PWRFL, int_hwre[API_PWRFL], INT_V_PWRFL, "power fail pending") },
 #endif
 #if defined (PDP15)
-    { FLDATA (ION_INH, ion_inh, 0) },
-    { FLDATA (APIENB, api_enb, 0) },
-    { ORDATA (APIREQ, api_req, 8) },
-    { ORDATA (APIACT, api_act, 8) },
-    { ORDATA (XR, XR, 18) },
-    { ORDATA (LR, LR, 18) },
-    { ORDATA (BR, BR, 18) },
-    { ORDATA (RR, RR, 18) },
-    { ORDATA (MMR, MMR, 18) },
-    { FLDATA (USMD, usmd, 0) },
-    { FLDATA (USMDBUF, usmd_buf, 0) },
-    { FLDATA (USMDDEF, usmd_defer, 0) },
-    { FLDATA (NEXM, nexm, 0) },
-    { FLDATA (PRVN, prvn, 0) },
-    { FLDATA (TRAPP, trap_pending, 0) },
-    { FLDATA (BANKM, memm, 0) },
-    { FLDATA (BANKM_INIT, memm_init, 0) },
-    { FLDATA (RESTP, rest_pending, 0) },
-    { FLDATA (PWRFL, int_hwre[API_PWRFL], INT_V_PWRFL) },
+    { FLDATAD (ION_INH, ion_inh, 0, "interrupt inhibit") },
+    { FLDATAD (APIENB, api_enb, 0, "API enable") },
+    { ORDATAD (APIREQ, api_req, 8, "API requesting levels") },
+    { ORDATAD (APIACT, api_act, 8, "API active levels") },
+    { ORDATAD (XR, XR, 18, "index register") },
+    { ORDATAD (LR, LR, 18, "limit register") },
+    { ORDATAD (BR, BR, 18, "memory protection bounds") },
+    { ORDATAD (RR, RR, 18, "memory protection relocation") },
+    { ORDATAD (MMR, MMR, 18, "memory protection control") },
+    { FLDATAD (USMD, usmd, 0, "user mode") },
+    { FLDATAD (USMDBUF, usmd_buf, 0, "user mode buffer") },
+    { FLDATAD (USMDDEF, usmd_defer, 0, "user mode load defer") },
+    { FLDATAD (NEXM, nexm, 0, "non-existent memory violation") },
+    { FLDATAD (PRVN, prvn, 0, "privilege violation") },
+    { FLDATAD (TRAPP, trap_pending, 0, "trap pending") },
+    { FLDATAD (BANKM, memm, 0, "bank mode") },
+    { FLDATAD (BANKM_INIT, memm_init, 0, "bank mode value after reset") },
+    { FLDATAD (RESTP, rest_pending, 0, "DBR or RES instruction pending") },
+    { FLDATAD (PWRFL, int_hwre[API_PWRFL], INT_V_PWRFL, "power fail flag") },
 #endif
-    { BRDATA (PCQ, pcq, 8, ADDRSIZE, PCQ_SIZE), REG_RO+REG_CIRC },
+    { BRDATAD (PCQ, pcq, 8, ADDRSIZE, PCQ_SIZE, "PC prior to last JMP, JMS, CAL or interrupt; most recent                        PC change first stop on undefineds instruction"), REG_RO+REG_CIRC },
     { ORDATA (PCQP, pcq_p, 6), REG_HRO },
-    { FLDATA (STOP_INST, stop_inst, 0) },
-    { DRDATA (XCT_MAX, xct_max, 8), PV_LEFT + REG_NZ },
-    { ORDATA (WRU, sim_int_char, 8) },
+    { FLDATAD (STOP_INST, stop_inst, 0, "stop on defined instruction") },
+    { DRDATAD (XCT_MAX, xct_max, 8, "max numb of chained XCT's allowed"), PV_LEFT + REG_NZ },
+    { ORDATAD (WRU, sim_int_char, 8, "interrupt character") },
     { NULL }  };
 
 MTAB cpu_mod[] = {
diff --git a/PDP18B/pdp18b_drm.c b/PDP18B/pdp18b_drm.c
index 3778e1e5..3976ffb1 100644
--- a/PDP18B/pdp18b_drm.c
+++ b/PDP18B/pdp18b_drm.c
@@ -100,14 +100,14 @@ UNIT drm_unit = {
     };
 
 REG drm_reg[] = {
-    { ORDATA (DA, drm_da, 9) },
-    { ORDATA (MA, drm_ma, 16) },
-    { FLDATA (INT, int_hwre[API_DRM], INT_V_DRM) },
-    { FLDATA (DONE, int_hwre[API_DRM], INT_V_DRM) },
-    { FLDATA (ERR, drm_err, 0) },
-    { ORDATA (WLK, drm_wlk, 32) },
-    { DRDATA (TIME, drm_time, 24), REG_NZ + PV_LEFT },
-    { FLDATA (STOP_IOE, drm_stopioe, 0) },
+    { ORDATAD (DA, drm_da, 9, "drum address (sector number") },
+    { ORDATAD (MA, drm_ma, 16, "current memor address") },
+    { FLDATAD (INT, int_hwre[API_DRM], INT_V_DRM, "interrupt pending flag") },
+    { FLDATAD (DONE, int_hwre[API_DRM], INT_V_DRM, "device done flag") },
+    { FLDATAD (ERR, drm_err, 0, "error flag") },
+    { ORDATAD (WLK, drm_wlk, 32, "write lock switches") },
+    { DRDATAD (TIME, drm_time, 24, "rotational latency, per word"), REG_NZ + PV_LEFT },
+    { FLDATAD (STOP_IOE, drm_stopioe, 0, "stop on I/O error") },
     { ORDATA (DEVNO, drm_dib.dev, 6), REG_HRO },
     { NULL }
     };
diff --git a/PDP18B/pdp18b_dt.c b/PDP18B/pdp18b_dt.c
index 8d07f56b..a9c83310 100644
--- a/PDP18B/pdp18b_dt.c
+++ b/PDP18B/pdp18b_dt.c
@@ -396,30 +396,30 @@ UNIT dt_unit[] = {
     };
 
 REG dt_reg[] = {
-    { ORDATA (DTSA, dtsa, 18) },
-    { ORDATA (DTSB, dtsb, 18) },
-    { ORDATA (DTDB, dtdb, 18) },
-    { FLDATA (INT, int_hwre[API_DTA], INT_V_DTA) },
+    { ORDATAD (DTSA, dtsa, 18, "status register A") },
+    { ORDATAD (DTSB, dtsb, 18, "status register B") },
+    { ORDATAD (DTDB, dtdb, 18, "data buffer") },
+    { FLDATAD (INT, int_hwre[API_DTA], INT_V_DTA, "interrupt pending flag") },
 #if defined (DTA_V_ENB)
-    { FLDATA (ENB, dtsa, DTA_V_ENB) },
+    { FLDATAD (ENB, dtsa, DTA_V_ENB, "interrupt enable flag") },
 #endif
-    { FLDATA (DTF, dtsb, DTB_V_DTF) },
+    { FLDATAD (DTF, dtsb, DTB_V_DTF, "DECtape flag") },
 #if defined (DTB_V_BEF)
-    { FLDATA (BEF, dtsb, DTB_V_BEF) },
+    { FLDATAD (BEF, dtsb, DTB_V_BEF, "block and flag") },
 #endif
-    { FLDATA (ERF, dtsb, DTB_V_ERF) },
-    { DRDATA (LTIME, dt_ltime, 31), REG_NZ },
-    { DRDATA (DCTIME, dt_dctime, 31), REG_NZ },
-    { ORDATA (SUBSTATE, dt_substate, 2) },
+    { FLDATAD (ERF, dtsb, DTB_V_ERF, "error flag") },
+    { DRDATAD (LTIME, dt_ltime, 31, "time between lines"), REG_NZ },
+    { DRDATAD (DCTIME, dt_dctime, 31, "time to declarate to a full stop"), REG_NZ },
+    { ORDATAD (SUBSTATE, dt_substate, 2, "read/write command substate") },
     { DRDATA (LBLK, dt_logblk, 12), REG_HIDDEN },
-    { URDATA (POS, dt_unit[0].pos, 10, T_ADDR_W, 0,
-              DT_NUMDR, PV_LEFT | REG_RO) },
-    { URDATA (STATT, dt_unit[0].STATE, 8, 18, 0,
-              DT_NUMDR, REG_RO) },
+    { URDATAD (POS, dt_unit[0].pos, 10, T_ADDR_W, 0,
+              DT_NUMDR, PV_LEFT | REG_RO, "positions in lines, units 0 to 7") },
+    { URDATAD (STATT, dt_unit[0].STATE, 8, 18, 0,
+              DT_NUMDR, REG_RO, "unit state, units 0 to 7") },
     { URDATA (LASTT, dt_unit[0].LASTT, 10, T_ADDR_W, 0,
               DT_NUMDR, REG_HRO) },
     { ORDATA (DEVNO, dt_dib.dev, 6), REG_HRO },
-    { FLDATA (STOP_OFFR, dt_stopoffr, 0) },
+    { FLDATAD (STOP_OFFR, dt_stopoffr, 0, "stop on off-reel error") },
 #if defined (TC02)
     { ORDATA (APIVEC, api_vec[API_DTA][INT_V_DTA], 6), REG_HRO },
 #endif
diff --git a/PDP18B/pdp18b_fpp.c b/PDP18B/pdp18b_fpp.c
index a8b11826..65427275 100644
--- a/PDP18B/pdp18b_fpp.c
+++ b/PDP18B/pdp18b_fpp.c
@@ -194,20 +194,20 @@ extern int32 Jms_word (int32 t);
 UNIT fpp_unit = { UDATA (NULL, 0, 0) };
 
 REG fpp_reg[] = {
-    { ORDATA (FIR, fir, 12) },
-    { ORDATA (EPA, fma.exp, 18) },
-    { FLDATA (FMAS, fma.sign, 0) },
-    { ORDATA (FMAH, fma.hi, 17) },
-    { ORDATA (FMAL, fma.lo, 18) },
-    { ORDATA (EPB, fmb.exp, 18) },
-    { FLDATA (FMBS, fmb.sign, 0) },
-    { ORDATA (FMBH, fmb.hi, 17) },
-    { ORDATA (FMBL, fmb.lo, 18) },
-    { FLDATA (FGUARD, fguard, 0) },
-    { ORDATA (FMQH, fmq.hi, 17) },
-    { ORDATA (FMQL, fmq.lo, 18) },
-    { ORDATA (JEA, jea, 15) },
-    { FLDATA (STOP_FPP, stop_fpp, 0) },
+    { ORDATAD (FIR, fir, 12, "floating instruction register") },
+    { ORDATAD (EPA, fma.exp, 18, "EPA (A exponent") },
+    { FLDATAD (FMAS, fma.sign, 0, "FMA sign") },
+    { ORDATAD (FMAH, fma.hi, 17, "FMA<1:17>") },
+    { ORDATAD (FMAL, fma.lo, 18, "FMA<18:35>") },
+    { ORDATAD (EPB, fmb.exp, 18, "EPB (B exponent)") },
+    { FLDATAD (FMBS, fmb.sign, 0, "FMB sign") },
+    { ORDATAD (FMBH, fmb.hi, 17, "FMB<1:17>") },
+    { ORDATAD (FMBL, fmb.lo, 18, "FMB<18:35>" ) },
+    { FLDATAD (FGUARD, fguard, 0, "guard bit") },
+    { ORDATAD (FMQH, fmq.hi, 17, "FMQ<1:17>") },
+    { ORDATAD (FMQL, fmq.lo, 18, "FMQ<18:35>") },
+    { ORDATAD (JEA, jea, 15, "exception address register") },
+    { FLDATAD (STOP_FPP, stop_fpp, 0, "stop if FB15 instruction decoded while FB15 is disabled") },
     { NULL }
     };
 
diff --git a/PDP18B/pdp18b_lp.c b/PDP18B/pdp18b_lp.c
index dfcfabe5..b024ded7 100644
--- a/PDP18B/pdp18b_lp.c
+++ b/PDP18B/pdp18b_lp.c
@@ -106,17 +106,17 @@ UNIT lp62_unit = {
     };
 
 REG lp62_reg[] = {
-    { ORDATA (BUF, lp62_unit.buf, 8) },
-    { FLDATA (INT, int_hwre[API_LPT], INT_V_LPT) },
-    { FLDATA (DONE, int_hwre[API_LPT], INT_V_LPT) },
-    { FLDATA (SPC, int_hwre[API_LPTSPC], INT_V_LPTSPC) },
-    { DRDATA (BPTR, lp62_bp, 6) },
+    { ORDATAD (BUF, lp62_unit.buf, 8, "last data item processed") },
+    { FLDATAD (INT, int_hwre[API_LPT], INT_V_LPT, "interrupt pending flag") },
+    { FLDATAD (DONE, int_hwre[API_LPT], INT_V_LPT, "device done flag") },
+    { FLDATAD (SPC, int_hwre[API_LPTSPC], INT_V_LPTSPC, "spacing done flag") },
+    { DRDATAD (BPTR, lp62_bp, 6, "print buffer pointer") },
     { ORDATA (STATE, lp62_spc, 6), REG_HRO },
     { FLDATA (OVRPR, lp62_ovrpr, 0), REG_HRO },
-    { DRDATA (POS, lp62_unit.pos, T_ADDR_W), PV_LEFT },
-    { DRDATA (TIME, lp62_unit.wait, 24), PV_LEFT },
-    { FLDATA (STOP_IOE, lp62_stopioe, 0) },
-    { BRDATA (LBUF, lp62_buf, 8, 8, LP62_BSIZE) },
+    { DRDATAD (POS, lp62_unit.pos, T_ADDR_W, "position in the output file"), PV_LEFT },
+    { DRDATAD (TIME, lp62_unit.wait, 24, "time from I/O initiation to interrupt"), PV_LEFT },
+    { FLDATAD (STOP_IOE, lp62_stopioe, 0, "stop on I/O error") },
+    { BRDATAD (LBUF, lp62_buf, 8, 8, LP62_BSIZE, "line buffer") },
     { ORDATA (DEVNO, lp62_dib.dev, 6), REG_HRO },
     { NULL }
     };
@@ -292,19 +292,19 @@ UNIT lp647_unit = {
     };
 
 REG lp647_reg[] = {
-    { ORDATA (BUF, lp647_unit.buf, 8) },
-    { FLDATA (INT, int_hwre[API_LPT], INT_V_LPT) },
-    { FLDATA (DONE, lp647_don, 0) },
+    { ORDATAD (BUF, lp647_unit.buf, 8, "last data item processed") },
+    { FLDATAD (INT, int_hwre[API_LPT], INT_V_LPT, "interrupt pending flag") },
+    { FLDATAD (DONE, lp647_don, 0, "device done flag") },
 #if defined (PDP9)
-    { FLDATA (ENABLE, lp647_ie, 0) },
+    { FLDATAD (ENABLE, lp647_ie, 0, "interrupt enable") },
 #endif
-    { FLDATA (ERR, lp647_err, 0) },
-    { DRDATA (BPTR, lp647_bp, 7) },
+    { FLDATAD (ERR, lp647_err, 0, "error flag") },
+    { DRDATAD (BPTR, lp647_bp, 7, "print buffer pointer") },
     { ORDATA (SCMD, lp647_iot, 6), REG_HRO },
-    { DRDATA (POS, lp647_unit.pos, T_ADDR_W), PV_LEFT },
-    { DRDATA (TIME, lp647_unit.wait, 24), PV_LEFT },
-    { FLDATA (STOP_IOE, lp647_stopioe, 0) },
-    { BRDATA (LBUF, lp647_buf, 8, 8, LP647_BSIZE) },
+    { DRDATAD (POS, lp647_unit.pos, T_ADDR_W, "position in the output file"), PV_LEFT },
+    { DRDATAD (TIME, lp647_unit.wait, 24, "time from I/O initiation to interrupt"), PV_LEFT },
+    { FLDATAD (STOP_IOE, lp647_stopioe, 0, "stop on I/O error") },
+    { BRDATAD (LBUF, lp647_buf, 8, 8, LP647_BSIZE, "line buffer") },
     { ORDATA (DEVNO, lp647_dib.dev, 6), REG_HRO },
     { NULL }
     };
@@ -531,14 +531,14 @@ UNIT lp09_unit = {
     };
 
 REG lp09_reg[] = {
-    { ORDATA (BUF, lp09_unit.buf, 7) },
-    { FLDATA (INT, int_hwre[API_LPT], INT_V_LPT) },
-    { FLDATA (DONE, lp09_don, 0) },
-    { FLDATA (ENABLE, lp09_ie, 0) },
-    { FLDATA (ERR, lp09_err, 0) },
-    { DRDATA (POS, lp09_unit.pos, T_ADDR_W), PV_LEFT },
-    { DRDATA (TIME, lp09_unit.wait, 24), PV_LEFT },
-    { FLDATA (STOP_IOE, lp09_stopioe, 0) },
+    { ORDATAD (BUF, lp09_unit.buf, 7, "last data item processed") },
+    { FLDATAD (INT, int_hwre[API_LPT], INT_V_LPT, "interrupt pending flag") },
+    { FLDATAD (DONE, lp09_don, 0, "device done flag") },
+    { FLDATAD (ENABLE, lp09_ie, 0, "interrupt enable") },
+    { FLDATAD (ERR, lp09_err, 0, "error flag") },
+    { DRDATAD (POS, lp09_unit.pos, T_ADDR_W, "position in the output file"), PV_LEFT },
+    { DRDATAD (TIME, lp09_unit.wait, 24, "time from initiation to inturrupt"), PV_LEFT },
+    { FLDATAD (STOP_IOE, lp09_stopioe, 0, "stop on I/O error") },
     { ORDATA (DEVNO, lp09_dib.dev, 6), REG_HRO },
     { ORDATA (APIVEC, api_vec[API_LPT][INT_V_LPT], 6), REG_HRO },
     { NULL }
@@ -714,16 +714,16 @@ UNIT lp15_unit = {
     };
 
 REG lp15_reg[] = {
-    { ORDATA (STA, lp15_sta, 18) },
-    { FLDATA (INT, int_hwre[API_LPT], INT_V_LPT) },
-    { FLDATA (ENABLE, lp15_ie, 0) },
-    { DRDATA (LCNT, lp15_lc, 9) },
-    { DRDATA (BPTR, lp15_bp, 8) },
-    { FLDATA (MODE, lp15_mode, 0) },
-    { DRDATA (POS, lp15_unit.pos, T_ADDR_W), PV_LEFT },
-    { DRDATA (TIME, lp15_unit.wait, 24), PV_LEFT },
-    { FLDATA (STOP_IOE, lp15_stopioe, 0) },
-    { BRDATA (LBUF, lp15_buf, 8, 8, LP15_BSIZE) },
+    { ORDATAD (STA, lp15_sta, 18, "status register") },
+    { FLDATAD (INT, int_hwre[API_LPT], INT_V_LPT, "interrupt pending flag") },
+    { FLDATAD (ENABLE, lp15_ie, 0, "interrupt enable") },
+    { DRDATAD (LCNT, lp15_lc, 9, "line counter") },
+    { DRDATAD (BPTR, lp15_bp, 8, "print buffer pointer") },
+    { FLDATAD (MODE, lp15_mode, 0, "mode flag") },
+    { DRDATAD (POS, lp15_unit.pos, T_ADDR_W, "position in the output file"), PV_LEFT },
+    { DRDATAD (TIME, lp15_unit.wait, 24, "time from I/O initiation to interrupt"), PV_LEFT },
+    { FLDATAD (STOP_IOE, lp15_stopioe, 0, "stop on I/O error") },
+    { BRDATAD (LBUF, lp15_buf, 8, 8, LP15_BSIZE, "line buffer") },
     { ORDATA (DEVNO, lp15_dib.dev, 6), REG_HRO },
     { ORDATA (APIVEC, api_vec[API_LPT][INT_V_LPT], 6), REG_HRO },
     { NULL }
diff --git a/PDP18B/pdp18b_mt.c b/PDP18B/pdp18b_mt.c
index 847a73d1..82ac6299 100644
--- a/PDP18B/pdp18b_mt.c
+++ b/PDP18B/pdp18b_mt.c
@@ -171,14 +171,14 @@ UNIT mt_unit[] = {
     };
 
 REG mt_reg[] = {
-    { ORDATA (STA, mt_sta, 18) },
-    { ORDATA (CMD, mt_cu, 18) },
-    { FLDATA (INT, int_hwre[API_MTA], INT_V_MTA) },
-    { FLDATA (STOP_IOE, mt_stopioe, 0) },
-    { DRDATA (TIME, mt_time, 24), PV_LEFT },
-    { URDATA (UST, mt_unit[0].USTAT, 8, 16, 0, MT_NUMDR, 0) },
-    { URDATA (POS, mt_unit[0].pos, 10, T_ADDR_W, 0,
-              MT_NUMDR, PV_LEFT | REG_RO) },
+    { ORDATAD (STA, mt_sta, 18, "main status") },
+    { ORDATAD (CMD, mt_cu, 18, "command") },
+    { FLDATAD (INT, int_hwre[API_MTA], INT_V_MTA, "interrupt pending flag") },
+    { FLDATAD (STOP_IOE, mt_stopioe, 0, "stop on I/O error") },
+    { DRDATAD (TIME, mt_time, 24, "record delay"), PV_LEFT },
+    { URDATAD (UST, mt_unit[0].USTAT, 8, 16, 0, MT_NUMDR, 0, "unit status, units 0 to 7") },
+    { URDATAD (POS, mt_unit[0].pos, 10, T_ADDR_W, 0,
+              MT_NUMDR, PV_LEFT | REG_RO, "position units 0 to 7") },
     { ORDATA (DEVNO, mt_dib.dev, 6), REG_HRO },
     { ORDATA (APIVEC, api_vec[API_MTA][INT_V_MTA], 6), REG_HRO },
     { NULL }
diff --git a/PDP18B/pdp18b_rf.c b/PDP18B/pdp18b_rf.c
index 8e0ed65a..1ed17c6e 100644
--- a/PDP18B/pdp18b_rf.c
+++ b/PDP18B/pdp18b_rf.c
@@ -149,14 +149,14 @@ UNIT rf_unit = {
     };
 
 REG rf_reg[] = {
-    { ORDATA (STA, rf_sta, 18) },
-    { ORDATA (DA, rf_da, 22) },
-    { ORDATA (BUF, rf_dbuf, 18) },
-    { FLDATA (INT, int_hwre[API_RF], INT_V_RF) },
-    { BRDATA (WLK, rf_wlk, 8, 16, RF_NUMDK) },
-    { DRDATA (TIME, rf_time, 24), PV_LEFT + REG_NZ },
-    { FLDATA (BURST, rf_burst, 0) },
-    { FLDATA (STOP_IOE, rf_stopioe, 0) },
+    { ORDATAD (STA, rf_sta, 18, "status") },
+    { ORDATAD (DA, rf_da, 22, "current disk address") },
+    { ORDATAD (BUF, rf_dbuf, 18, "data buffer (diagnostic only)") },
+    { FLDATAD (INT, int_hwre[API_RF], INT_V_RF, "interrupt pending flag") },
+    { BRDATAD (WLK, rf_wlk, 8, 16, RF_NUMDK, "write lock switches for disks 0 to 7") },
+    { DRDATAD (TIME, rf_time, 24, "rotational delay per word"), PV_LEFT + REG_NZ },
+    { FLDATAD (BURST, rf_burst, 0, "burst flag") },
+    { FLDATAD (STOP_IOE, rf_stopioe, 0, "stop on I/O error") },
     { DRDATA (CAPAC, rf_unit.capac, 31), PV_LEFT + REG_HRO },
     { ORDATA (DEVNO, rf_dib.dev, 6), REG_HRO },
     { ORDATA (APIVEC, api_vec[API_RF][INT_V_RF], 6), REG_HRO },
diff --git a/PDP18B/pdp18b_rp.c b/PDP18B/pdp18b_rp.c
index 912d3968..13dfe2c4 100644
--- a/PDP18B/pdp18b_rp.c
+++ b/PDP18B/pdp18b_rp.c
@@ -195,16 +195,16 @@ UNIT rp_unit[] = {
     };
 
 REG rp_reg[] = {
-    { ORDATA (STA, rp_sta, 18) },
-    { ORDATA (STB, rp_stb, 18) },
-    { ORDATA (DA, rp_da, 18) },
-    { ORDATA (MA, rp_ma, 18) },
-    { ORDATA (WC, rp_wc, 18) },
-    { FLDATA (INT, int_hwre[API_RP], INT_V_RP) },
-    { FLDATA (BUSY, rp_busy, 0) },
-    { FLDATA (STOP_IOE, rp_stopioe, 0) },
-    { DRDATA (STIME, rp_swait, 24), PV_LEFT },
-    { DRDATA (RTIME, rp_rwait, 24), PV_LEFT },
+    { ORDATAD (STA, rp_sta, 18, "status A") },
+    { ORDATAD (STB, rp_stb, 18, "status B") },
+    { ORDATAD (DA, rp_da, 18, "disk address") },
+    { ORDATAD (MA, rp_ma, 18, "current memory address") },
+    { ORDATAD (WC, rp_wc, 18, "word count") },
+    { FLDATAD (INT, int_hwre[API_RP], INT_V_RP, "interrupt pending flag") },
+    { FLDATAD (BUSY, rp_busy, 0, "control busy flag") },
+    { FLDATAD (STOP_IOE, rp_stopioe, 0, "stop on I/O error") },
+    { DRDATAD (STIME, rp_swait, 24, "seek time per cylinder"), PV_LEFT },
+    { DRDATAD (RTIME, rp_rwait, 24, "rotational delay"), PV_LEFT },
     { ORDATA (DEVNO, rp_dib.dev, 6), REG_HRO },
     { ORDATA (APIVEC, api_vec[API_RP][INT_V_RP], 6), REG_HRO },
     { NULL }
diff --git a/PDP18B/pdp18b_stddev.c b/PDP18B/pdp18b_stddev.c
index 8e446d73..506e143a 100644
--- a/PDP18B/pdp18b_stddev.c
+++ b/PDP18B/pdp18b_stddev.c
@@ -177,14 +177,14 @@ DIB clk_dib = { 0, 0, &clk_iors, { NULL } };
 UNIT clk_unit = { UDATA (&clk_svc, UNIT_IDLE, 0), 16000 };
 
 REG clk_reg[] = {
-    { FLDATA (INT, int_hwre[API_CLK], INT_V_CLK) },
-    { FLDATA (DONE, int_hwre[API_CLK], INT_V_CLK) },
-    { FLDATA (ENABLE, clk_state, 0) },
+    { FLDATAD (INT, int_hwre[API_CLK], INT_V_CLK, "interrupt pending flag") },
+    { FLDATAD (DONE, int_hwre[API_CLK], INT_V_CLK, "device done flag") },
+    { FLDATAD (ENABLE, clk_state, 0, "clock enable") },
 #if defined (PDP15)
-    { ORDATA (TASKTIMER, clk_task_timer, 18) },
+    { ORDATAD (TASKTIMER, clk_task_timer, 18, "task timer") },
     { DRDATA (TASKLAST, clk_task_last, 32), REG_HRO },
 #endif
-    { DRDATA (TIME, clk_unit.wait, 24), REG_NZ + PV_LEFT },
+    { DRDATAD (TIME, clk_unit.wait, 24, "clock frequency"), REG_NZ + PV_LEFT },
     { DRDATA (TPS, clk_tps, 8), PV_LEFT + REG_HRO },
     { ORDATA (APIVEC, api_vec[API_CLK][INT_V_CLK], 6), REG_HRO },
     { NULL }
@@ -224,16 +224,16 @@ UNIT ptr_unit = {
     };
 
 REG ptr_reg[] = {
-    { ORDATA (BUF, ptr_unit.buf, 18) },
-    { FLDATA (INT, int_hwre[API_PTR], INT_V_PTR) },
-    { FLDATA (DONE, int_hwre[API_PTR], INT_V_PTR) },
+    { ORDATAD (BUF, ptr_unit.buf, 18, "last data item processed") },
+    { FLDATAD (INT, int_hwre[API_PTR], INT_V_PTR, "interrupt pending flag") },
+    { FLDATAD (DONE, int_hwre[API_PTR], INT_V_PTR, "device done flag") },
 #if defined (IOS_PTRERR)
-    { FLDATA (ERR, ptr_err, 0) },
+    { FLDATAD (ERR, ptr_err, 0, "error flag") },
 #endif
     { ORDATA (STATE, ptr_state, 5), REG_HRO },
-    { DRDATA (POS, ptr_unit.pos, T_ADDR_W), PV_LEFT },
-    { DRDATA (TIME, ptr_unit.wait, 24), PV_LEFT },
-    { FLDATA (STOP_IOE, ptr_stopioe, 0) },
+    { DRDATAD (POS, ptr_unit.pos, T_ADDR_W, "position in the input file"), PV_LEFT },
+    { DRDATAD (TIME, ptr_unit.wait, 24, "time from I/O initiation to interrupt"), PV_LEFT },
+    { FLDATAD(STOP_IOE, ptr_stopioe, 0, "stop on I/O error") },
     { ORDATA (APIVEC, api_vec[API_PTR][INT_V_PTR], 6), REG_HRO },
     { NULL }
     };
@@ -267,15 +267,15 @@ UNIT ptp_unit = {
     };
 
 REG ptp_reg[] = {
-    { ORDATA (BUF, ptp_unit.buf, 8) },
-    { FLDATA (INT, int_hwre[API_PTP], INT_V_PTP) },
-    { FLDATA (DONE, int_hwre[API_PTP], INT_V_PTP) },
+    { ORDATAD (BUF, ptp_unit.buf, 8, "last data item processed") },
+    { FLDATAD (INT, int_hwre[API_PTP], INT_V_PTP, "interrupt pending flag") },
+    { FLDATAD (DONE, int_hwre[API_PTP], INT_V_PTP, "device done flag") },
 #if defined (IOS_PTPERR)
-    { FLDATA (ERR, ptp_err, 0) },
+    { FLDATAD (ERR, ptp_err, 0, "error flag") },
 #endif
-    { DRDATA (POS, ptp_unit.pos, T_ADDR_W), PV_LEFT },
-    { DRDATA (TIME, ptp_unit.wait, 24), PV_LEFT },
-    { FLDATA (STOP_IOE, ptp_stopioe, 0) },
+    { DRDATAD (POS, ptp_unit.pos, T_ADDR_W, "position in the output file"), PV_LEFT },
+    { DRDATAD (TIME, ptp_unit.wait, 24, "time from I/O initiation to inturrupt"), PV_LEFT },
+    { FLDATAD (STOP_IOE, ptp_stopioe, 0, "stop on I/O error") },
     { NULL }
     };
 
@@ -323,17 +323,17 @@ DIB tti_dib = { DEV_TTI, 1, &tti_iors, { &tti } };
 UNIT tti_unit = { UDATA (&tti_svc, UNIT_IDLE+TT_MODE_KSR+TTUF_HDX, 0), 0 };
 
 REG tti_reg[] = {
-    { ORDATA (BUF, tti_unit.buf, TTI_WIDTH) },
+    { ORDATAD (BUF, tti_unit.buf, TTI_WIDTH, "last data item processed") },
 #if defined (KSR28)
     { ORDATA (BUF2ND, tti_2nd, TTI_WIDTH), REG_HRO },
 #endif
-    { FLDATA (INT, int_hwre[API_TTI], INT_V_TTI) },
-    { FLDATA (DONE, int_hwre[API_TTI], INT_V_TTI) },
+    { FLDATAD (INT, int_hwre[API_TTI], INT_V_TTI, "interrupt pending flag") },
+    { FLDATAD (DONE, int_hwre[API_TTI], INT_V_TTI, "device done flag") },
 #if defined (PDP15)
     { FLDATA (FDPX, tti_fdpx, 0) },
 #endif
-    { DRDATA (POS, tti_unit.pos, T_ADDR_W), PV_LEFT },
-    { DRDATA (TIME, tti_unit.wait, 24), PV_LEFT },
+    { DRDATAD (POS, tti_unit.pos, T_ADDR_W, "number of characters input"), PV_LEFT },
+    { DRDATAD (TIME, tti_unit.wait, 24, "input polling interval                                                          (if 0, the keyboard is polled synchronously with line clock)"), PV_LEFT },
     { NULL }
     };
 
@@ -384,14 +384,14 @@ DIB tto_dib = { DEV_TTO, 1, &tto_iors, { &tto } };
 UNIT tto_unit = { UDATA (&tto_svc, TT_MODE_KSR, 0), 1000 };
 
 REG tto_reg[] = {
-    { ORDATA (BUF, tto_unit.buf, TTO_WIDTH) },
+    { ORDATAD (BUF, tto_unit.buf, TTO_WIDTH, "last data item processed") },
 #if defined (KSR28)
     { FLDATA (SHIFT, tty_shift, 0), REG_HRO },
 #endif
-    { FLDATA (INT, int_hwre[API_TTO], INT_V_TTO) },
-    { FLDATA (DONE, int_hwre[API_TTO], INT_V_TTO) },
-    { DRDATA (POS, tto_unit.pos, T_ADDR_W), PV_LEFT },
-    { DRDATA (TIME, tto_unit.wait, 24), PV_LEFT },
+    { FLDATAD (INT, int_hwre[API_TTO], INT_V_TTO, "interrupt pending flag") },
+    { FLDATAD (DONE, int_hwre[API_TTO], INT_V_TTO, "device done flag") },
+    { DRDATAD (POS, tto_unit.pos, T_ADDR_W, "number of characters output"), PV_LEFT },
+    { DRDATAD (TIME, tto_unit.wait, 24, "time from I/O initiation to interrupt"), PV_LEFT },
     { NULL }
     };
 
diff --git a/PDP18B/pdp18b_tt1.c b/PDP18B/pdp18b_tt1.c
index 17d37f3e..8409bdef 100644
--- a/PDP18B/pdp18b_tt1.c
+++ b/PDP18B/pdp18b_tt1.c
@@ -102,10 +102,10 @@ DIB ttix_dib = {
 UNIT ttix_unit = { UDATA (&ttix_svc, UNIT_IDLE|UNIT_ATTABLE, 0), KBD_POLL_WAIT };
 
 REG ttix_reg[] = {
-    { BRDATA (BUF, ttix_buf, 8, 8, TTX_MAXL) },
-    { ORDATA (DONE, ttix_done, TTX_MAXL) },
-    { FLDATA (INT, int_hwre[API_TTI1], INT_V_TTI1) },
-    { DRDATA (TIME, ttix_unit.wait, 24), REG_NZ + PV_LEFT },
+    { BRDATAD (BUF, ttix_buf, 8, 8, TTX_MAXL, "last character received, lines 0 to 3/15") },
+    { ORDATAD (DONE, ttix_done, TTX_MAXL, "input ready flags, line 0 on right") },
+    { FLDATAD (INT, int_hwre[API_TTI1], INT_V_TTI1, "interrupt pending flag") },
+    { DRDATAD (TIME, ttix_unit.wait, 24, "keyboard polling interval"), REG_NZ + PV_LEFT },
     { ORDATA (DEVNUM, ttix_dib.dev, 6), REG_HRO },
 #if defined (PDP15)
     { ORDATA (APIVEC, api_vec[API_TTI1][INT_V_TTI1], 6), REG_HRO },
@@ -164,11 +164,11 @@ UNIT ttox_unit[] = {
     };
 
 REG ttox_reg[] = {
-    { BRDATA (BUF, ttox_buf, 8, 8, TTX_MAXL) },
-    { ORDATA (DONE, ttox_done, TTX_MAXL) },
-    { FLDATA (INT, int_hwre[API_TTO1], INT_V_TTO1) },
-    { URDATA (TIME, ttox_unit[0].wait, 10, 24, 0,
-              TTX_MAXL, PV_LEFT) },
+    { BRDATAD (BUF, ttox_buf, 8, 8, TTX_MAXL, "last character transmitted, lines 0 to 3/15") },
+    { ORDATAD (DONE, ttox_done, TTX_MAXL, "output ready flags, line 0 on right") },
+    { FLDATAD (INT, int_hwre[API_TTO1], INT_V_TTO1, "interrupt pending flag") },
+    { URDATAD (TIME, ttox_unit[0].wait, 10, 24, 0,
+              TTX_MAXL, PV_LEFT, "time from initiation to interrupt, lines 0 to 3/15") },
 #if defined (PDP15)
     { ORDATA (APIVEC, api_vec[API_TTO1][INT_V_TTO1], 6), REG_HRO },
 #endif