diff --git a/LGP/lgp_sys.c b/LGP/lgp_sys.c
index 7dbca98e..589f88e8 100644
--- a/LGP/lgp_sys.c
+++ b/LGP/lgp_sys.c
@@ -237,21 +237,21 @@ else fprint_val (st, addr, dptr->aradix, dptr->awidth, PV_LEFT);
 return;
 }
 
-t_addr lgp_parse_addr (DEVICE *dptr, char *cptr, char **tptr)
+t_addr lgp_parse_addr (DEVICE *dptr, const char *cptr, const char **tptr)
 {
 t_addr ad, ea;
 
 if ((dptr == sim_devices[0]) &&
     ((sim_switches & SWMASK ('T')) ||
     ((cpu_unit.flags & UNIT_TTSS_D) && !(sim_switches & SWMASK ('N'))))) {
-    ad = (t_addr) strtotv (cptr, (const char **)tptr, 10);
+    ad = (t_addr) strtotv (cptr, tptr, 10);
     if (((ad / 100) >= NTK_30) || ((ad % 100) >= NSC_30)) {
         *tptr = cptr;
         return 0;
         }
     ea = ((ad / 100) * NSC_30) | (ad % 100);
     }
-else ea = (t_addr) strtotv (cptr, (const char **)tptr, dptr->aradix);
+else ea = (t_addr) strtotv (cptr, tptr, dptr->aradix);
 return ea;
 }
 
@@ -379,7 +379,8 @@ return SCPE_ARG;
 t_stat parse_sym_m (char *cptr, t_value *val, int32 sw)
 {
 uint32 ea, sgn;
-char *tptr, gbuf[CBUFSIZE];
+const char *tptr;
+char gbuf[CBUFSIZE];
 
 if (*cptr == '-') {
     cptr++;
diff --git a/PDQ-3/pdq3_fdc.c b/PDQ-3/pdq3_fdc.c
index de4f6c63..0f0ff808 100644
--- a/PDQ-3/pdq3_fdc.c
+++ b/PDQ-3/pdq3_fdc.c
@@ -349,7 +349,7 @@ static t_stat fdc_start(UNIT *uptr,int time) {
 
 static t_stat fdc_stop(UNIT *uptr) {
   /* request service */
-  sim_debug(DBG_FD_SVC, &fdc_dev, DBG_PCFORMAT2 "Cancel Service\n", DBG_PC, time);
+  sim_debug(DBG_FD_SVC, &fdc_dev, DBG_PCFORMAT2 "Cancel Service\n", DBG_PC);
   return sim_cancel(uptr);
 }
 
diff --git a/PDQ-3/pdq3_sys.c b/PDQ-3/pdq3_sys.c
index 7962da09..8919d4c8 100644
--- a/PDQ-3/pdq3_sys.c
+++ b/PDQ-3/pdq3_sys.c
@@ -155,7 +155,7 @@ void pdq3_fprint_addr (FILE *st, DEVICE *dptr, t_addr addr)
   return;
 }
 
-t_addr pdq3_parse_addr (DEVICE *dptr, char *cptr, char **tptr)
+t_addr pdq3_parse_addr (DEVICE *dptr, const char *cptr, const char **tptr)
 {
   t_addr seg, off;
   if (cptr[0] == '#') {
@@ -207,13 +207,13 @@ static t_stat pdq3_cmd_exstack(int32 arg, char *buf)
 
 static t_stat pdq3_cmd_exmscw(int32 arg, char *buf)
 {
-  char* next;
+  const char* next;
   return dbg_dump_mscw(stdout, buf[0] ? pdq3_parse_addr(&cpu_dev, buf, &next) : reg_mp);
 }
 
 static t_stat pdq3_cmd_extib(int32 arg, char *buf)
 {
-  char* next;
+  const char* next;
   return dbg_dump_tib(stdout, buf[0] ? pdq3_parse_addr(&cpu_dev, buf, &next) : reg_ctp);
 }
 
@@ -222,7 +222,7 @@ static t_stat pdq3_cmd_exseg(int32 arg, char *buf)
   t_stat rc;
   uint16 nsegs;
   uint16 segnum, segptr;
-  char* next;
+  const char* next;
   FILE* fd = stdout; /* XXX */
   
   if (reg_ssv < 0x2030 || reg_ssv > 0xf000) {
diff --git a/doc/simh.doc b/doc/simh.doc
index ca7c50ab..bf282b22 100644
Binary files a/doc/simh.doc and b/doc/simh.doc differ
diff --git a/scp.c b/scp.c
index 50cb21a5..4c0d77f1 100644
--- a/scp.c
+++ b/scp.c
@@ -347,7 +347,7 @@ char* (*sim_vm_read) (char *ptr, int32 size, FILE *stream) = NULL;
 void (*sim_vm_post) (t_bool from_scp) = NULL;
 CTAB *sim_vm_cmd = NULL;
 void (*sim_vm_fprint_addr) (FILE *st, DEVICE *dptr, t_addr addr) = NULL;
-t_addr (*sim_vm_parse_addr) (DEVICE *dptr, char *cptr, char **tptr) = NULL;
+t_addr (*sim_vm_parse_addr) (DEVICE *dptr, const char *cptr, const char **tptr) = NULL;
 t_value (*sim_vm_pc_value) (void) = NULL;
 t_bool (*sim_vm_is_subroutine_call) (t_addr **ret_addrs) = NULL;
 t_bool (*sim_vm_fprint_stopped) (FILE *st, t_stat reason) = NULL;
@@ -2111,8 +2111,8 @@ return SCPE_EXIT;
 /* Used when sorting a list of command names */
 static int _cmd_name_compare (const void *pa, const void *pb)
 {
-CTAB **a = (CTAB **)pa;
-CTAB **b = (CTAB **)pb;
+CTAB * const *a = (CTAB * const *)pa;
+CTAB * const *b = (CTAB * const *)pb;
 
 return strcmp((*a)->name, (*b)->name);
 }
@@ -3306,7 +3306,7 @@ else {
         }
     else {                                              /* not reg, check for memory */
         if (sim_dfdev && sim_vm_parse_addr)             /* get addr */
-            addr = sim_vm_parse_addr (sim_dfdev, (char *)gbuf, (char **)&gptr);
+            addr = sim_vm_parse_addr (sim_dfdev, gbuf, &gptr);
         else addr = (t_addr) strtotv (gbuf, &gptr, sim_dfdev->dradix);
         if (gbuf == gptr)                               /* error? */
             return SCPE_NXREG;
@@ -5974,7 +5974,7 @@ if ((flag == RU_RUN) || (flag == RU_GO)) {              /* run or go */
         if (*cptr != 0)                                 /* should be end */
             return SCPE_2MARG;
         if (sim_vm_parse_addr)                          /* address parser? */
-            pcv = sim_vm_parse_addr (sim_dflt_dev, gbuf, (char **)&tptr);
+            pcv = sim_vm_parse_addr (sim_dflt_dev, gbuf, &tptr);
         else pcv = strtotv (gbuf, &tptr, sim_PC->radix);/* parse PC */
         if ((tptr == gbuf) || (*tptr != 0) ||           /* error? */
             (pcv > width_mask[sim_PC->width]))
@@ -6643,7 +6643,8 @@ t_stat dep_reg (int32 flag, char *cptr, REG *rptr, uint32 idx)
 t_stat r;
 t_value val, mask;
 int32 rdx;
-char *tptr, gbuf[CBUFSIZE];
+const char *tptr;
+char gbuf[CBUFSIZE];
 
 if ((cptr == NULL) || (rptr == NULL))
     return SCPE_IERR;
@@ -7283,7 +7284,7 @@ else {
         }
     else {
         if (dptr && sim_vm_parse_addr)                      /* get low */
-            *lo = sim_vm_parse_addr (dptr, (char *)cptr, (char **)&tptr);
+            *lo = sim_vm_parse_addr (dptr, cptr, &tptr);
         else
             *lo = (t_addr) strtotv (cptr, &tptr, rdx);
         if (cptr == tptr)                                   /* error? */
@@ -7291,7 +7292,7 @@ else {
         if ((*tptr == '-') || (*tptr == ':')) {             /* range? */
             cptr = tptr + 1;
             if (dptr && sim_vm_parse_addr)                  /* get high */
-                *hi = sim_vm_parse_addr (dptr, (char *)cptr, (char **)&tptr);
+                *hi = sim_vm_parse_addr (dptr, cptr, &tptr);
             else *hi = (t_addr) strtotv (cptr, &tptr, rdx);
             if (cptr == tptr)
                 return NULL;
@@ -7938,7 +7939,7 @@ for (logop = cmpop = -1; (c = *cptr++); ) {             /* loop thru clauses */
         logval = strtotv (cptr, &tptr, radix);
         if (cptr == tptr)
             return NULL;
-        cptr = (char *)tptr;
+        cptr = tptr;
         }
     else if ((sptr = strchr (cmpstr, c))) {             /* check for boolop */
         cmpop = (int32)(sptr - cmpstr);
@@ -7949,7 +7950,7 @@ for (logop = cmpop = -1; (c = *cptr++); ) {             /* loop thru clauses */
         cmpval = strtotv (cptr, &tptr, radix);
         if (cptr == tptr)
             return NULL;
-        cptr = (char *)tptr;
+        cptr = tptr;
         }
     else return NULL;
     }                                                   /* end for */
@@ -8152,10 +8153,10 @@ int32 nodigit;
 t_value val;
 uint32 c, digit;
 
-*endptr = (char *)inptr;                                /* assume fails */
+*endptr = inptr;                                        /* assume fails */
 if ((radix < 2) || (radix > 36))
     return 0;
-while (sim_isspace (*inptr))                                /* bypass white space */
+while (sim_isspace (*inptr))                            /* bypass white space */
     inptr++;
 val = 0;
 nodigit = 1;
@@ -8174,7 +8175,7 @@ for (c = *inptr; sim_isalnum(c); c = *++inptr) {        /* loop through char */
     }
 if (nodigit)                                            /* no digits? */
     return 0;
-*endptr = (char *)inptr;                                /* result pointer */
+*endptr = inptr;                                        /* result pointer */
 return val;
 }
 
@@ -9021,7 +9022,7 @@ return SCPE_OK;
 
 /* Set expect */
 
-t_stat sim_set_expect (EXPECT *exp, char *cptr)
+t_stat sim_set_expect (EXPECT *exp, const char *cptr)
 {
 char gbuf[CBUFSIZE], *tptr;
 const char *c1ptr;
@@ -9035,7 +9036,7 @@ if (*cptr == '[') {
     cnt = (int32) strtotv (cptr + 1, &c1ptr, 10);
     if ((cptr == c1ptr) || (*c1ptr != ']'))
         return sim_messagef (SCPE_ARG, "Invalid Repeat count specification\n");
-    cptr = (char *)(c1ptr + 1);
+    cptr = c1ptr + 1;
     while (sim_isspace(*cptr))
         ++cptr;
     }
@@ -9055,7 +9056,7 @@ return sim_exp_set (exp, gbuf, cnt, (after ? after : exp->after), sim_switches,
 
 /* Clear expect */
 
-t_stat sim_set_noexpect (EXPECT *exp, char *cptr)
+t_stat sim_set_noexpect (EXPECT *exp, const char *cptr)
 {
 char gbuf[CBUFSIZE];
 
@@ -9136,7 +9137,7 @@ return SCPE_OK;
 
 /* Set/Add an expect rule */
 
-t_stat sim_exp_set (EXPECT *exp, const char *match, int32 cnt, uint32 after, int32 switches, char *act)
+t_stat sim_exp_set (EXPECT *exp, const char *match, int32 cnt, uint32 after, int32 switches, const char *act)
 {
 EXPTAB *ep;
 uint8 *match_buf;
@@ -9179,7 +9180,7 @@ else {
         free (match_buf);
         return sim_messagef (SCPE_ARG, "Case independed matching is only valid for RegEx expect rules\n");
         }
-    sim_data_trace(exp->dptr, exp->dptr->units, (uint8 *)match, "", strlen(match)+1, "Expect Match String", exp->dbit);
+    sim_data_trace(exp->dptr, exp->dptr->units, (const uint8 *)match, "", strlen(match)+1, "Expect Match String", exp->dbit);
     if (SCPE_OK != sim_decode_quoted_string (match, match_buf, &match_size)) {
         free (match_buf);
         return sim_messagef (SCPE_ARG, "Invalid quoted string\n");
@@ -9215,7 +9216,7 @@ if (switches & EXP_TYP_REGEX) {
     match_buf = NULL;
     }
 else {
-    sim_data_trace(exp->dptr, exp->dptr->units, (uint8 *)match, "", strlen(match)+1, "Expect Match String", exp->dbit);
+    sim_data_trace(exp->dptr, exp->dptr->units, (const uint8 *)match, "", strlen(match)+1, "Expect Match String", exp->dbit);
     sim_decode_quoted_string (match, match_buf, &match_size);
     ep->match = match_buf;
     ep->size = match_size;
diff --git a/scp.h b/scp.h
index aa732ceb..44e0bf4f 100644
--- a/scp.h
+++ b/scp.h
@@ -183,9 +183,9 @@ t_stat sim_send_input (SEND *snd, uint8 *data, size_t size, uint32 after, uint32
 t_stat sim_show_send_input (FILE *st, SEND *snd);
 t_bool sim_send_poll_data (SEND *snd, t_stat *stat);
 t_stat sim_send_clear (SEND *snd);
-t_stat sim_set_expect (EXPECT *exp, char *cptr);
-t_stat sim_set_noexpect (EXPECT *exp, char *cptr);
-t_stat sim_exp_set (EXPECT *exp, const char *match, int32 cnt, uint32 after, int32 switches, char *act);
+t_stat sim_set_expect (EXPECT *exp, const char *cptr);
+t_stat sim_set_noexpect (EXPECT *exp, const char *cptr);
+t_stat sim_exp_set (EXPECT *exp, const char *match, int32 cnt, uint32 after, int32 switches, const char *act);
 t_stat sim_exp_clr (EXPECT *exp, const char *match);
 t_stat sim_exp_clrall (EXPECT *exp);
 t_stat sim_exp_show (FILE *st, EXPECT *exp, const char *match);
@@ -282,7 +282,7 @@ extern char* (*sim_vm_read) (char *ptr, int32 size, FILE *stream);
 extern void (*sim_vm_post) (t_bool from_scp);
 extern CTAB *sim_vm_cmd;
 extern void (*sim_vm_fprint_addr) (FILE *st, DEVICE *dptr, t_addr addr);
-extern t_addr (*sim_vm_parse_addr) (DEVICE *dptr, char *cptr, char **tptr);
+extern t_addr (*sim_vm_parse_addr) (DEVICE *dptr, const char *cptr, const char **tptr);
 extern t_bool (*sim_vm_fprint_stopped) (FILE *st, t_stat reason);
 extern t_value (*sim_vm_pc_value) (void);
 extern t_bool (*sim_vm_is_subroutine_call) (t_addr **ret_addrs);
diff --git a/sim_serial.c b/sim_serial.c
index bb184e65..80e712b1 100644
--- a/sim_serial.c
+++ b/sim_serial.c
@@ -222,8 +222,8 @@ return;
 /* Used when sorting a list of serial port names */
 static int _serial_name_compare (const void *pa, const void *pb)
 {
-SERIAL_LIST *a = (SERIAL_LIST *)pa;
-SERIAL_LIST *b = (SERIAL_LIST *)pb;
+const SERIAL_LIST *a = (const SERIAL_LIST *)pa;
+const SERIAL_LIST *b = (const SERIAL_LIST *)pb;
 
 return strcmp(a->name, b->name);
 }
diff --git a/sim_sock.c b/sim_sock.c
index 04263ba5..84b58fa3 100644
--- a/sim_sock.c
+++ b/sim_sock.c
@@ -384,7 +384,7 @@ static int     WSAAPI s_getnameinfo (const struct sockaddr *sa, socklen_t salen,
 {
 struct hostent *he;
 struct servent *se = NULL;
-struct sockaddr_in *sin = (struct sockaddr_in *)sa;
+const struct sockaddr_in *sin = (const struct sockaddr_in *)sa;
 
 if (sin->sin_family != PF_INET)
     return EAI_FAMILY;
@@ -416,7 +416,7 @@ if ((host) && (hostlen > 0)) {
     if (flags & NI_NUMERICHOST)
         he = NULL;
     else
-        he = gethostbyaddr((char *)&sin->sin_addr, 4, AF_INET);
+        he = gethostbyaddr((const char *)&sin->sin_addr, 4, AF_INET);
     if (he) {
         if (hostlen < strlen(he->h_name)+1)
             return EAI_OVERFLOW;
diff --git a/sim_tmxr.c b/sim_tmxr.c
index 713cf008..49b8d9bf 100644
--- a/sim_tmxr.c
+++ b/sim_tmxr.c
@@ -4387,10 +4387,12 @@ return SCPE_OK;
    If an error occurs, the original line order is not disturbed.
 */
 
-t_stat tmxr_set_lnorder (UNIT *uptr, int32 val, char *cptr, void *desc)
+t_stat tmxr_set_lnorder (UNIT *uptr, int32 val, char *carg, void *desc)
 {
 TMXR *mp = (TMXR *) desc;
+char *tbuf;
 char *tptr;
+const char *cptr;
 t_addr low, high, max = (t_addr) mp->lines - 1;
 int32 *list;
 t_bool *set;
@@ -4400,7 +4402,7 @@ t_stat result = SCPE_OK;
 if (mp->lnorder == NULL)                                /* line connection order undefined? */
     return SCPE_NXPAR;                                  /* "Non-existent parameter" error */
 
-else if ((cptr == NULL) || (*cptr == '\0'))             /* line range not supplied? */
+else if ((carg == NULL) || (*carg == '\0'))             /* line range not supplied? */
     return SCPE_MISVAL;                                 /* "Missing value" error */
 
 list = (int32 *) calloc (mp->lines, sizeof (int32));    /* allocate new line order array */
@@ -4415,12 +4417,15 @@ if (set == NULL) {                                      /* allocation failed? */
     return SCPE_MEM;                                    /* report it */
     }
 
-tptr = cptr + strlen (cptr);                            /* append a semicolon */
+tbuf = (char *) calloc (strlen(carg)+2, sizeof(*carg));
+strcpy (tbuf, carg);
+tptr = tbuf + strlen (tbuf);                            /* append a semicolon */
 *tptr++ = ';';                                          /*   to the command string */
 *tptr = '\0';                                           /*   to make parsing easier for get_range */
+cptr = tbuf;
 
 while (*cptr) {                                         /* parse command string */
-    cptr = (char *)get_range (NULL, cptr, &low, &high, 10, max, ';');/* get a line range */
+    cptr = get_range (NULL, cptr, &low, &high, 10, max, ';');/* get a line range */
 
     if (cptr == NULL) {                                 /* parsing error? */
         result = SCPE_ARG;                              /* "Invalid argument" error */
@@ -4460,6 +4465,7 @@ if (result == SCPE_OK) {                                /* assignment successful
 
 free (list);                                            /* free list allocation */
 free (set);                                             /* free set allocation */
+free (tbuf);                                            /* free arg copy with ; */
 
 return result;
 }