diff --git a/src/between.c b/src/between.c
index 132560196..5a1825c61 100644
--- a/src/between.c
+++ b/src/between.c
@@ -8,7 +8,7 @@
 */
 SEXP between(SEXP x, SEXP lower, SEXP upper, SEXP incbounds, SEXP NAboundsArg, SEXP checkArg) {
   int nprotect = 0;
-  R_len_t nx = length(x), nl = length(lower), nu = length(upper);
+  const R_len_t nx = length(x), nl = length(lower), nu = length(upper);
   if (!nx || !nl || !nu)
     return (allocVector(LGLSXP, 0));
   const int longest = MAX(MAX(nx, nl), nu);
@@ -20,13 +20,13 @@ SEXP between(SEXP x, SEXP lower, SEXP upper, SEXP incbounds, SEXP NAboundsArg, S
   const int longestBound = MAX(nl, nu);  // just for when check=TRUE
   if (!IS_TRUE_OR_FALSE(incbounds))
     error(_("%s must be TRUE or FALSE"), "incbounds");
-  const bool open = !LOGICAL(incbounds)[0];
-  if (!isLogical(NAboundsArg) || LOGICAL(NAboundsArg)[0]==FALSE)
+  const bool open = !LOGICAL_RO(incbounds)[0];
+  if (!isLogical(NAboundsArg) || LOGICAL_RO(NAboundsArg)[0]==FALSE)
     error(_("NAbounds must be TRUE or NA"));
-  const bool NAbounds = LOGICAL(NAboundsArg)[0]==TRUE;
+  const bool NAbounds = LOGICAL_RO(NAboundsArg)[0]==TRUE;
   if (!IS_TRUE_OR_FALSE(checkArg))
     error(_("%s must be TRUE or FALSE"), "check");
-  const bool check = LOGICAL(checkArg)[0];
+  const bool check = LOGICAL_RO(checkArg)[0];
   const bool verbose = GetVerbose();
 
   // check before potential coercion which ignores methods, #7164
@@ -70,13 +70,13 @@ SEXP between(SEXP x, SEXP lower, SEXP upper, SEXP incbounds, SEXP NAboundsArg, S
   const int uppMask = recycleUpp ? 0 : INT_MAX;
   SEXP ans = PROTECT(allocVector(LGLSXP, longest)); nprotect++;
   int *restrict ansp = LOGICAL(ans);
-  double tic=omp_get_wtime();
+  const double tic=omp_get_wtime();
 
   switch (TYPEOF(x)) {
   case INTSXP: {
-    const int *lp = INTEGER(lower);
-    const int *up = INTEGER(upper);
-    const int *xp = INTEGER(x);
+    const int *lp = INTEGER_RO(lower);
+    const int *up = INTEGER_RO(upper);
+    const int *xp = INTEGER_RO(x);
     if (check) for (int i=0; i<longestBound; ++i) {
       const int l=lp[i & lowMask], u=up[i & uppMask];
       if (l!=NA_INTEGER && u!=NA_INTEGER && l>u)
@@ -103,9 +103,9 @@ SEXP between(SEXP x, SEXP lower, SEXP upper, SEXP incbounds, SEXP NAboundsArg, S
 
   case REALSXP:
     if (INHERITS(x, char_integer64)) {
-      const int64_t *lp = (int64_t *)REAL(lower);
-      const int64_t *up = (int64_t *)REAL(upper);
-      const int64_t *xp = (int64_t *)REAL(x);
+      const int64_t *lp = (const int64_t*)REAL_RO(lower);
+      const int64_t* up = (const int64_t*)REAL_RO(upper);
+      const int64_t* xp = (const int64_t*)REAL_RO(x);
       if (check) for (int i=0; i<longestBound; ++i) {
         const int64_t l=lp[i & lowMask], u=up[i & uppMask];
         if (l!=NA_INTEGER64 && u!=NA_INTEGER64 && l>u)
@@ -128,9 +128,9 @@ SEXP between(SEXP x, SEXP lower, SEXP upper, SEXP incbounds, SEXP NAboundsArg, S
       }
       if (verbose) Rprintf(_("between parallel processing of integer64 took %8.3fs\n"), omp_get_wtime()-tic);
     } else {
-      const double *lp = REAL(lower);
-      const double *up = REAL(upper);
-      const double *xp = REAL(x);
+      const double *lp = REAL_RO(lower);
+      const double *up = REAL_RO(upper);
+      const double *xp = REAL_RO(x);
       if (check) for (int i=0; i<longestBound; ++i) {
         const double l=lp[i & lowMask], u=up[i & uppMask];
         if (!isnan(l) && !isnan(u) && l>u)
diff --git a/src/bmerge.c b/src/bmerge.c
index 5b778f19b..43e4f5608 100644
--- a/src/bmerge.c
+++ b/src/bmerge.c
@@ -26,7 +26,8 @@ Differences over standard binary search (e.g. bsearch in stdlib.h) :
 static const SEXP *idtVec, *xdtVec;
 static const int *icols, *xcols;
 static SEXP nqgrp;
-static int ncol, *o, *xo, *retFirst, *retLength, *retIndex, *allLen1, *allGrp1, *rollends, ilen, anslen;
+static int ncol, *o, *xo, *retFirst, *retLength, *retIndex, *allLen1, *allGrp1, ilen, anslen;
+static const int* rollends;
 static int *op, nqmaxgrp;
 static int ctr, nomatch; // populating matches for non-equi joins
 enum {ALL, FIRST, LAST, ERR} mult = ALL;
@@ -56,8 +57,8 @@ SEXP bmerge(SEXP idt, SEXP xdt, SEXP icolsArg, SEXP xcolsArg, SEXP xoArg, SEXP r
   if ((LENGTH(icolsArg)==0 || LENGTH(xcolsArg)==0) && LENGTH(idt)>0) // We let through LENGTH(i) == 0 for tests 2126.*
     internal_error(__func__, "icols and xcols must be non-empty integer vectors");
   if (LENGTH(icolsArg) > LENGTH(xcolsArg)) internal_error(__func__, "length(icols) [%d] > length(xcols) [%d]", LENGTH(icolsArg), LENGTH(xcolsArg)); // # nocov
-  icols = INTEGER(icolsArg);
-  xcols = INTEGER(xcolsArg);
+  icols = INTEGER_RO(icolsArg);
+  xcols = INTEGER_RO(xcolsArg);
   xN = LENGTH(xdt) ? LENGTH(VECTOR_ELT(xdt,0)) : 0;
   iN = ilen = anslen = LENGTH(idt) ? LENGTH(VECTOR_ELT(idt,0)) : 0;
   ncol = LENGTH(icolsArg);    // there may be more sorted columns in x than involved in the join
@@ -94,7 +95,7 @@ SEXP bmerge(SEXP idt, SEXP xdt, SEXP icolsArg, SEXP xcolsArg, SEXP xoArg, SEXP r
   rollabs = fabs(roll);
   if (!isLogical(rollendsArg) || LENGTH(rollendsArg) != 2)
     error(_("rollends must be a length 2 logical vector"));
-  rollends = LOGICAL(rollendsArg);
+  rollends = LOGICAL_RO(rollendsArg);
 
   if (isNull(nomatchArg)) {
     nomatch=0;
diff --git a/src/cj.c b/src/cj.c
index 0598f94ea..753b79d58 100644
--- a/src/cj.c
+++ b/src/cj.c
@@ -24,7 +24,7 @@ SEXP cj(SEXP base_list) {
     switch(TYPEOF(source)) {
     case LGLSXP:
     case INTSXP: {
-      const int *restrict sourceP = INTEGER(source);
+      const int *restrict sourceP = INTEGER_RO(source);
       int *restrict targetP = INTEGER(target);
       #pragma omp parallel for num_threads(getDTthreads(thislen*eachrep, true))
       // default static schedule so two threads won't write to same cache line in last column
@@ -40,7 +40,7 @@ SEXP cj(SEXP base_list) {
       }
     } break;
     case REALSXP: {
-      const double *restrict sourceP = REAL(source);
+      const double *restrict sourceP = REAL_RO(source);
       double *restrict targetP = REAL(target);
       #pragma omp parallel for num_threads(getDTthreads(thislen*eachrep, true))
       for (int i=0; i<thislen; ++i) {
@@ -54,7 +54,7 @@ SEXP cj(SEXP base_list) {
       }
     } break;
     case CPLXSXP: {
-      const Rcomplex *restrict sourceP = COMPLEX(source);
+      const Rcomplex *restrict sourceP = COMPLEX_RO(source);
       Rcomplex *restrict targetP = COMPLEX(target);
       #pragma omp parallel for num_threads(getDTthreads(thislen*eachrep, true))
       for (int i=0; i<thislen; ++i) {
diff --git a/src/coalesce.c b/src/coalesce.c
index 10b7b7757..1f3ca318e 100644
--- a/src/coalesce.c
+++ b/src/coalesce.c
@@ -10,8 +10,8 @@ SEXP coalesce(SEXP x, SEXP inplaceArg, SEXP nan_is_na_arg) {
   if (TYPEOF(x)!=VECSXP) internal_error(__func__, "input is list(...) at R level"); // # nocov
   if (!IS_TRUE_OR_FALSE(inplaceArg)) internal_error(__func__, "argument 'inplaceArg' must be TRUE or FALSE"); // # nocov
   if (!IS_TRUE_OR_FALSE(nan_is_na_arg)) internal_error(__func__, "argument 'nan_is_na_arg' must be TRUE or FALSE"); // # nocov
-  const bool inplace = LOGICAL(inplaceArg)[0];
-  const bool nan_is_na = LOGICAL(nan_is_na_arg)[0];
+  const bool inplace = LOGICAL_RO(inplaceArg)[0];
+  const bool nan_is_na = LOGICAL_RO(nan_is_na_arg)[0];
   const bool verbose = GetVerbose();
   int nprotect = 0;
   if (length(x)==0 || isNull(VECTOR_ELT(x,0))) return R_NilValue;  // coalesce(NULL, "foo") return NULL even though character type mismatches type NULL
@@ -63,7 +63,7 @@ SEXP coalesce(SEXP x, SEXP inplaceArg, SEXP nan_is_na_arg) {
     for (int j=0; j<nval; ++j) {
       SEXP item = VECTOR_ELT(x, j+off);
       if (length(item)==1) {
-        int tt = INTEGER(item)[0];
+        int tt = INTEGER_RO(item)[0];
         if (tt==NA_INTEGER) continue;  // singleton NA can be skipped
         finalVal = tt;
         break;  // stop early on the first singleton that is not NA; minimizes deepest loop body below
@@ -108,7 +108,7 @@ SEXP coalesce(SEXP x, SEXP inplaceArg, SEXP nan_is_na_arg) {
         for (int j=0; j<nval; ++j) {
           SEXP item = VECTOR_ELT(x, j+off);
           if (length(item)==1) {
-            double tt = REAL(item)[0];
+            double tt = REAL_RO(item)[0];
             if (ISNAN(tt)) continue;
             finalVal = tt;
             break;
@@ -127,7 +127,7 @@ SEXP coalesce(SEXP x, SEXP inplaceArg, SEXP nan_is_na_arg) {
         for (int j=0; j<nval; ++j) {
           SEXP item = VECTOR_ELT(x, j+off);
           if (length(item)==1) {
-            double tt = REAL(item)[0];
+            double tt = REAL_RO(item)[0];
             if (ISNA(tt)) continue;
             finalVal = tt;
             break;
diff --git a/src/dogroups.c b/src/dogroups.c
index d4f774568..6ef83d6c6 100644
--- a/src/dogroups.c
+++ b/src/dogroups.c
@@ -69,7 +69,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   int nprotect=0;
   SEXP ans=NULL, jval, thiscol, BY, N, I, GRP, iSD, xSD, rownames, s, RHS, target, source;
   Rboolean wasvector, firstalloc=FALSE, NullWarnDone=FALSE;
-  const bool verbose = LOGICAL(verboseArg)[0]==1;
+  const bool verbose = LOGICAL_RO(verboseArg)[0]==1;
   double tstart=0, tblock[10]={0}; int nblock[10]={0}; // For verbose printing, tstart is updated each block
   bool hasPrinted = false;
 
@@ -77,8 +77,8 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   if (TYPEOF(starts) != INTSXP) internal_error(__func__, "starts not integer"); // # nocov
   if (TYPEOF(lens) != INTSXP) internal_error(__func__, "lens not integer"); // # nocov
   // starts can now be NA (<0): if (INTEGER(starts)[0]<0 || INTEGER(lens)[0]<0) error(_("starts[1]<0 or lens[1]<0"));
-  if (!isNull(jiscols) && LENGTH(order) && !LOGICAL(on)[0]) internal_error(__func__, "jiscols not NULL but o__ has length"); // # nocov
-  if (!isNull(xjiscols) && LENGTH(order) && !LOGICAL(on)[0]) internal_error(__func__, "xjiscols not NULL but o__ has length"); // # nocov
+  if (!isNull(jiscols) && LENGTH(order) && !LOGICAL_RO(on)[0]) internal_error(__func__, "jiscols not NULL but o__ has length"); // # nocov
+  if (!isNull(xjiscols) && LENGTH(order) && !LOGICAL_RO(on)[0]) internal_error(__func__, "xjiscols not NULL but o__ has length"); // # nocov
   if(!isEnvironment(env)) error(_("env is not an environment"));
   ngrp = length(starts);  // the number of groups  (nrow(groups) will be larger when by)
   ngrpcols = length(grpcols);
@@ -87,14 +87,14 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   SEXP SDall = PROTECT(findVar(install(".SDall"), env)); nprotect++;  // PROTECT for rchk
   SEXP SD = PROTECT(findVar(install(".SD"), env)); nprotect++;
   
-  const bool showProgress = LOGICAL(showProgressArg)[0]==1 && ngrp > 1; // showProgress only if more than 1 group
+  const bool showProgress = LOGICAL_RO(showProgressArg)[0]==1 && ngrp > 1; // showProgress only if more than 1 group
   double startTime = (showProgress) ? wallclock() : 0; // For progress printing, startTime is set at the beginning
   double nextTime = (showProgress) ? startTime+3 : 0; // wait 3 seconds before printing progress
 
   defineVar(sym_BY, BY = PROTECT(allocVector(VECSXP, ngrpcols)), env); nprotect++;  // PROTECT for rchk
   SEXP bynames = PROTECT(allocVector(STRSXP, ngrpcols));  nprotect++;   // TO DO: do we really need bynames, can we assign names afterwards in one step?
   for (int i=0; i<ngrpcols; ++i) {
-    int j = INTEGER(grpcols)[i]-1;
+    const int j = INTEGER_RO(grpcols)[i]-1;
     SET_VECTOR_ELT(BY, i, allocVector(TYPEOF(VECTOR_ELT(groups, j)),
       nrowgroups ? 1 : 0)); // TODO: might be able to be 1 always but 0 when 'groups' are integer(0) seem sensible. #2440 was involved in the past.
     // Fix for #36, by cols with attributes when also used in `j` lost the attribute.
@@ -118,7 +118,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   iSD = PROTECT(findVar(install(".iSD"), env)); nprotect++; // 1-row and possibly no cols (if no i variables are used via JIS)
   xSD = PROTECT(findVar(install(".xSD"), env)); nprotect++;
   R_len_t maxGrpSize = 0;
-  const int *ilens = INTEGER(lens), n=LENGTH(lens);
+  const int *ilens = INTEGER_RO(lens), n=LENGTH(lens);
   for (R_len_t i=0; i<n; ++i) {
     if (ilens[i] > maxGrpSize) maxGrpSize = ilens[i];
   }
@@ -132,7 +132,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   for (s = ATTRIB(SD); s != R_NilValue && TAG(s)!=R_RowNamesSymbol; s = CDR(s));  // getAttrib0 basically but that's hidden in attrib.c; #loop_counter_not_local_scope_ok
   if (s==R_NilValue) error(_("row.names attribute of .SD not found"));
   rownames = CAR(s);
-  if (!isInteger(rownames) || LENGTH(rownames)!=2 || INTEGER(rownames)[0]!=NA_INTEGER) error(_("row.names of .SD isn't integer length 2 with NA as first item; i.e., .set_row_names(). [%s %d %d]"),type2char(TYPEOF(rownames)),LENGTH(rownames),INTEGER(rownames)[0]);
+  if (!isInteger(rownames) || LENGTH(rownames)!=2 || INTEGER_RO(rownames)[0]!=NA_INTEGER) error(_("row.names of .SD isn't integer length 2 with NA as first item; i.e., .set_row_names(). [%s %d %d]"),type2char(TYPEOF(rownames)),LENGTH(rownames),INTEGER_RO(rownames)[0]);
 
   // fetch names of .SD and prepare symbols. In case they are copied-on-write by user assigning to those variables
   // using <- in j (which is valid, useful and tested), they are repointed to the .SD cols for each group.
@@ -149,7 +149,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
       internal_error(__func__, "SDall %d length = %d != %d", i+1, LENGTH(this), maxGrpSize); // # nocov
     nameSyms[i] = install(CHAR(STRING_ELT(names, i)));
     // fixes http://stackoverflow.com/questions/14753411/why-does-data-table-lose-class-definition-in-sd-after-group-by
-    copyMostAttrib(VECTOR_ELT(dt,INTEGER(dtcols)[i]-1), this);  // not names, otherwise test 778 would fail
+    copyMostAttrib(VECTOR_ELT(dt,INTEGER_RO(dtcols)[i]-1), this);  // not names, otherwise test 778 would fail
     SET_TRUELENGTH(this, -maxGrpSize);  // marker for anySpecialStatic(); see its comments
   }
 
@@ -170,8 +170,8 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   Rboolean jexpIsSymbolOtherThanSD = (isSymbol(jexp) && strcmp(CHAR(PRINTNAME(jexp)),".SD")!=0);  // test 559
 
   ansloc = 0;
-  const int *istarts = INTEGER(starts);
-  const int *iorder = INTEGER(order);
+  const int *istarts = INTEGER_RO(starts);
+  const int *iorder = INTEGER_RO(order);
 
   // We just want to set anyNA for later. We do it only once for the whole operation
   // because it is a rare edge case for it to be true. See #4892.
@@ -205,15 +205,15 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
     }
 
     if (length(iSD) && length(VECTOR_ELT(iSD, 0))/*#4364*/) for (int j=0; j<length(iSD); ++j) {   // either this or the next for() will run, not both
-      memrecycle(VECTOR_ELT(iSD,j), R_NilValue, 0, 1, VECTOR_ELT(groups, INTEGER(jiscols)[j]-1), i, 1, j+1, "Internal error assigning to iSD");
+      memrecycle(VECTOR_ELT(iSD,j), R_NilValue, 0, 1, VECTOR_ELT(groups, INTEGER_RO(jiscols)[j]-1), i, 1, j+1, "Internal error assigning to iSD");
       // we're just use memrecycle here to assign a single value
     }
     // igrp determines the start of the current group in rows of dt (0 based).
     // if jiscols is not null, we have a by = .EACHI, so the start is exactly i.
     // Otherwise, igrp needs to be determined from starts, potentially taking care about the order if present.
-    igrp = !isNull(jiscols) ? i : (length(grporder) ? INTEGER(grporder)[istarts[i]-1]-1 : istarts[i]-1);
+    igrp = !isNull(jiscols) ? i : (length(grporder) ? INTEGER_RO(grporder)[istarts[i]-1]-1 : istarts[i]-1);
     if (igrp>=0 && nrowgroups) for (int j=0; j<length(BY); ++j) {    // igrp can be -1 so 'if' is important, otherwise memcpy crash
-      memrecycle(VECTOR_ELT(BY,j), R_NilValue, 0, 1, VECTOR_ELT(groups, INTEGER(grpcols)[j]-1), igrp, 1, j+1, "Internal error assigning to BY");
+      memrecycle(VECTOR_ELT(BY,j), R_NilValue, 0, 1, VECTOR_ELT(groups, INTEGER_RO(grpcols)[j]-1), igrp, 1, j+1, "Internal error assigning to BY");
     }
     if (istarts[i] == NA_INTEGER || (LENGTH(order) && iorder[ istarts[i]-1 ]==NA_INTEGER)) {
       for (int j=0; j<length(SDall); ++j) {
@@ -242,9 +242,9 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
         for (int j=0; j<grpn; ++j) iI[j] = rownum+j+1;
         if (rownum>=0) {
           for (int j=0; j<length(SDall); ++j)
-            memrecycle(VECTOR_ELT(SDall,j), R_NilValue, 0, grpn, VECTOR_ELT(dt, INTEGER(dtcols)[j]-1), rownum, grpn, j+1, "Internal error assigning to SDall");
+            memrecycle(VECTOR_ELT(SDall,j), R_NilValue, 0, grpn, VECTOR_ELT(dt, INTEGER_RO(dtcols)[j]-1), rownum, grpn, j+1, "Internal error assigning to SDall");
           for (int j=0; j<length(xSD); ++j)
-            memrecycle(VECTOR_ELT(xSD,j), R_NilValue, 0, 1, VECTOR_ELT(dt, INTEGER(xjiscols)[j]-1), rownum, 1, j+1, "Internal error assigning to xSD");
+            memrecycle(VECTOR_ELT(xSD,j), R_NilValue, 0, 1, VECTOR_ELT(dt, INTEGER_RO(xjiscols)[j]-1), rownum, 1, j+1, "Internal error assigning to xSD");
         }
         if (verbose) { tblock[0] += wallclock()-tstart; nblock[0]++; }
       } else {
@@ -252,7 +252,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
         for (int k=0; k<grpn; ++k) iI[k] = iorder[rownum+k];
         for (int j=0; j<length(SDall); ++j) {
           // this is the main non-contiguous gather, and is parallel (within-column) for non-SEXP
-          subsetVectorRaw(VECTOR_ELT(SDall,j), VECTOR_ELT(dt,INTEGER(dtcols)[j]-1), I, anyNA);
+          subsetVectorRaw(VECTOR_ELT(SDall,j), VECTOR_ELT(dt,INTEGER_RO(dtcols)[j]-1), I, anyNA);
         }
         if (verbose) { tblock[1] += wallclock()-tstart; nblock[1]++; }
         // The two blocks have separate timing statements to make sure which is running
@@ -288,7 +288,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
         if (isArray(thiscol)) {
           SEXP dims = PROTECT(getAttrib(thiscol, R_DimSymbol));
           int nDimensions=0;
-          for (int d=0; d<LENGTH(dims); ++d) if (INTEGER(dims)[d] > 1) ++nDimensions;
+          for (int d=0; d<LENGTH(dims); ++d) if (INTEGER_RO(dims)[d] > 1) ++nDimensions;
           UNPROTECT(1);
           if (nDimensions > 1)
             error(_("Entry %d for group %d in j=list(...) is an array with %d dimensions > 1, which is disallowed. \"Break\" the array yourself with c() or as.vector() if that is intentional."), j+1, i+1, nDimensions);
@@ -304,14 +304,14 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
           error(_("RHS of := is NULL during grouped assignment, but it's not possible to delete parts of a column."));
         int vlen = length(RHS);
         if (vlen>1 && vlen!=grpn) {
-          SEXP colname = isNull(VECTOR_ELT(dt, INTEGER(lhs)[j]-1)) ? STRING_ELT(newnames, INTEGER(lhs)[j]-origncol-1) : STRING_ELT(dtnames,INTEGER(lhs)[j]-1);
+          SEXP colname = isNull(VECTOR_ELT(dt, INTEGER_RO(lhs)[j]-1)) ? STRING_ELT(newnames, INTEGER_RO(lhs)[j]-origncol-1) : STRING_ELT(dtnames,INTEGER_RO(lhs)[j]-1);
           error(_("Supplied %d items to be assigned to group %d of size %d in column '%s'. The RHS length must either be 1 (single values are ok) or match the LHS length exactly. If you wish to 'recycle' the RHS please use rep() explicitly to make this intent clear to readers of your code."),vlen,i+1,grpn,CHAR(colname));
           // e.g. in #91 `:=` did not issue recycling warning during grouping. Now it is error not warning.
         }
       }
       int n = LENGTH(VECTOR_ELT(dt, 0));
       for (int j=0; j<length(lhs); ++j) {
-        int colj = INTEGER(lhs)[j]-1;
+        int colj = INTEGER_RO(lhs)[j]-1;
         target = VECTOR_ELT(dt, colj);
         RHS = VECTOR_ELT(jval,j%LENGTH(jval));
         if (isNull(target)) {
@@ -333,7 +333,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
           RHS = PROTECT(copyAsPlain(RHS));
           copied = true;
         }
-        const char *warn = memrecycle(target, order, INTEGER(starts)[i]-1, grpn, RHS, 0, -1, 0, "");
+        const char *warn = memrecycle(target, order, INTEGER_RO(starts)[i]-1, grpn, RHS, 0, -1, 0, "");
         // can't error here because length mismatch already checked for all jval columns before starting to add any new columns
         if (copied) UNPROTECT(1);
         if (warn)
@@ -371,7 +371,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
         nprotect++;
         firstalloc=TRUE;
         for(int j=0; j<ngrpcols; ++j) {
-          thiscol = VECTOR_ELT(groups, INTEGER(grpcols)[j]-1);
+          thiscol = VECTOR_ELT(groups, INTEGER_RO(grpcols)[j]-1);
           SET_VECTOR_ELT(ans, j, allocVector(TYPEOF(thiscol), estn));
           copyMostAttrib(thiscol, VECTOR_ELT(ans,j));  // not names, otherwise test 778 would fail
         }
@@ -411,7 +411,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
     }
     // write the group values to ans, recycled to match the nrow of the result for this group ...
     for (int j=0; j<ngrpcols; ++j) {
-      memrecycle(VECTOR_ELT(ans,j), R_NilValue, ansloc, maxn, VECTOR_ELT(groups, INTEGER(grpcols)[j]-1), igrp, 1, j+1, "Internal error recycling group values");
+      memrecycle(VECTOR_ELT(ans,j), R_NilValue, ansloc, maxn, VECTOR_ELT(groups, INTEGER_RO(grpcols)[j]-1), igrp, 1, j+1, "Internal error recycling group values");
     }
     // Now copy jval into ans ...
     for (int j=0; j<njval; ++j) {
diff --git a/src/fcast.c b/src/fcast.c
index 334dfd7e8..961f429a4 100644
--- a/src/fcast.c
+++ b/src/fcast.c
@@ -5,8 +5,8 @@
 
 // TO DO: margins
 SEXP fcast(SEXP lhs, SEXP val, SEXP nrowArg, SEXP ncolArg, SEXP idxArg, SEXP fill, SEXP fill_d, SEXP is_agg, SEXP some_fillArg) {
-  int nrows=INTEGER(nrowArg)[0], ncols=INTEGER(ncolArg)[0];
-  int nlhs=length(lhs), nval=length(val), *idx = INTEGER(idxArg);
+  const int nrows=INTEGER_RO(nrowArg)[0], ncols=INTEGER_RO(ncolArg)[0];
+  const int nlhs=length(lhs), nval=length(val), *idx = INTEGER(idxArg);
   SEXP target;
 
   SEXP ans = PROTECT(allocVector(VECSXP, nlhs + (nval * ncols)));
@@ -15,7 +15,7 @@ SEXP fcast(SEXP lhs, SEXP val, SEXP nrowArg, SEXP ncolArg, SEXP idxArg, SEXP fil
     SET_VECTOR_ELT(ans, i, VECTOR_ELT(lhs, i));
   }
   // get val cols
-  bool some_fill = LOGICAL(some_fillArg)[0];
+  const bool some_fill = LOGICAL_RO(some_fillArg)[0];
   for (int i=0; i<nval; ++i) {
     const SEXP thiscol = VECTOR_ELT(val, i);
     SEXP thisfill = fill;
@@ -37,43 +37,43 @@ SEXP fcast(SEXP lhs, SEXP val, SEXP nrowArg, SEXP ncolArg, SEXP idxArg, SEXP fil
     switch (thistype) {
     case INTSXP:
     case LGLSXP: {
-      const int *ithiscol = INTEGER(thiscol);
+      const int *ithiscol = INTEGER_RO(thiscol);
       const int *ithisfill = 0;
-      if (some_fill) ithisfill = INTEGER(thisfill);
+      if (some_fill) ithisfill = INTEGER_RO(thisfill);
       for (int j=0; j<ncols; ++j) {
         SET_VECTOR_ELT(ans, nlhs+j+i*ncols, target=allocVector(thistype, nrows) );
         int *itarget = INTEGER(target);
         copyMostAttrib(thiscol, target);
         for (int k=0; k<nrows; ++k) {
-          int thisidx = idx[k*ncols + j];
+          const int thisidx = idx[k*ncols + j];
           itarget[k] = (thisidx == NA_INTEGER) ? ithisfill[0] : ithiscol[thisidx-1];
         }
       }
     } break;
     case REALSXP: {
-      const double *dthiscol = REAL(thiscol);
+      const double *dthiscol = REAL_RO(thiscol);
       const double *dthisfill = 0;
-      if (some_fill) dthisfill = REAL(thisfill);
+      if (some_fill) dthisfill = REAL_RO(thisfill);
       for (int j=0; j<ncols; ++j) {
         SET_VECTOR_ELT(ans, nlhs+j+i*ncols, target=allocVector(thistype, nrows) );
         double *dtarget = REAL(target);
         copyMostAttrib(thiscol, target);
         for (int k=0; k<nrows; ++k) {
-          int thisidx = idx[k*ncols + j];
+          const int thisidx = idx[k*ncols + j];
           dtarget[k] = (thisidx == NA_INTEGER) ? dthisfill[0] : dthiscol[thisidx-1];
         }
       }
     } break;
     case CPLXSXP: {
-      const Rcomplex *zthiscol = COMPLEX(thiscol);
+      const Rcomplex *zthiscol = COMPLEX_RO(thiscol);
       const Rcomplex *zthisfill = 0;
-      if (some_fill) zthisfill = COMPLEX(thisfill);
+      if (some_fill) zthisfill = COMPLEX_RO(thisfill);
       for (int j=0; j<ncols; ++j) {
         SET_VECTOR_ELT(ans, nlhs+j+i*ncols, target=allocVector(thistype, nrows) );
         Rcomplex *ztarget = COMPLEX(target);
         copyMostAttrib(thiscol, target);
         for (int k=0; k<nrows; ++k) {
-          int thisidx = idx[k*ncols + j];
+          const int thisidx = idx[k*ncols + j];
           ztarget[k] = (thisidx == NA_INTEGER) ? zthisfill[0] : zthiscol[thisidx-1];
         }
       }
@@ -83,7 +83,7 @@ SEXP fcast(SEXP lhs, SEXP val, SEXP nrowArg, SEXP ncolArg, SEXP idxArg, SEXP fil
         SET_VECTOR_ELT(ans, nlhs+j+i*ncols, target=allocVector(thistype, nrows) );
         copyMostAttrib(thiscol, target);
         for (int k=0; k<nrows; ++k) {
-          int thisidx = idx[k*ncols + j];
+          const int thisidx = idx[k*ncols + j];
           SET_STRING_ELT(target, k, (thisidx == NA_INTEGER) ? STRING_ELT(thisfill, 0) : STRING_ELT(thiscol, thisidx-1));
         }
       }
@@ -93,7 +93,7 @@ SEXP fcast(SEXP lhs, SEXP val, SEXP nrowArg, SEXP ncolArg, SEXP idxArg, SEXP fil
         SET_VECTOR_ELT(ans, nlhs+j+i*ncols, target=allocVector(thistype, nrows) );
         copyMostAttrib(thiscol, target);
         for (int k=0; k<nrows; ++k) {
-          int thisidx = idx[k*ncols + j];
+          const int thisidx = idx[k*ncols + j];
           SET_VECTOR_ELT(target, k, (thisidx == NA_INTEGER) ? VECTOR_ELT(thisfill, 0) : VECTOR_ELT(thiscol, thisidx-1));
         }
       }
diff --git a/src/forder.c b/src/forder.c
index a4564497b..7001e537c 100644
--- a/src/forder.c
+++ b/src/forder.c
@@ -115,8 +115,8 @@ void internal_error_with_cleanup(const char *call_name, const char *format, ...)
 
 static void push(const int *x, const int n) {
   if (!retgrp) return;  // clearer to have the switch here rather than before each call
-  int me = omp_get_thread_num();
-  int newn = gs_thread_n[me] + n;
+  const int me = omp_get_thread_num();
+  const int newn = gs_thread_n[me] + n;
   if (gs_thread_alloc[me] < newn) {
     gs_thread_alloc[me] = (newn < nrow/3) ? (1+(newn*2)/4096)*4096 : nrow;  // [2|3] to not overflow and 3 not 2 to avoid allocating close to nrow (nrow groups occurs when all size 1 groups)
     gs_thread[me] = realloc(gs_thread[me], sizeof(*gs_thread[me])*gs_thread_alloc[me]);
@@ -128,11 +128,11 @@ static void push(const int *x, const int n) {
 
 static void flush(void) {
   if (!retgrp) return;
-  int me = omp_get_thread_num();
-  int n = gs_thread_n[me];
+  const int me = omp_get_thread_num();
+  const int n = gs_thread_n[me];
   // normally doesn't happen, can be encountered under heavy load, #7051
   if (!n) return; // # nocov
-  int newn = gs_n + n;
+  const int newn = gs_n + n;
   if (gs_alloc < newn) {
     gs_alloc = (newn < nrow/3) ? (1+(newn*2)/4096)*4096 : nrow;
     gs = realloc(gs, sizeof(*gs)*gs_alloc);
@@ -174,7 +174,7 @@ static void range_i32(const int32_t *x, const int n, uint64_t *out_min, uint64_t
   int na_count = i;
   if (i<n) max = min = x[i++];
   for(; i<n; i++) {
-    int tmp = x[i];
+    const int tmp = x[i];
     if (tmp>max) max=tmp;
     else if (tmp<min) {
       if (tmp==NA_INTEGER) na_count++;
@@ -262,7 +262,7 @@ static void cradix_r(SEXP *xsub, int n, int radix)
     if (thiscounts[i]) thiscounts[i] = (itmp += thiscounts[i]);  // don't cummulate through 0s, important below
   }
   for (int i=n-1; i>=0; i--) {
-    uint8_t thisx = radix<LENGTH(xsub[i]) ? (uint8_t)(CHAR(xsub[i])[radix]) : 1;
+    const uint8_t thisx = radix<LENGTH(xsub[i]) ? (uint8_t)(CHAR(xsub[i])[radix]) : 1;
     cradix_xtmp[--thiscounts[thisx]] = xsub[i];
   }
   memcpy(xsub, cradix_xtmp, n*sizeof(SEXP));
@@ -399,9 +399,9 @@ SEXP setNumericRounding(SEXP droundArg)
 // init.c has initial call with default of 2
 {
   if (!isInteger(droundArg) || LENGTH(droundArg)!=1) error(_("Must an integer or numeric vector length 1"));
-  if (INTEGER(droundArg)[0] < 0 || INTEGER(droundArg)[0] > 2) error(_("Must be 2, 1 or 0"));
+  if (INTEGER(droundArg)[0] < 0 || INTEGER_RO(droundArg)[0] > 2) error(_("Must be 2, 1 or 0"));
   int oldRound = dround;
-  dround = INTEGER(droundArg)[0];
+  dround = INTEGER_RO(droundArg)[0];
   dmask = dround ? 1 << (8*dround-1) : 0;
   return ScalarInteger(oldRound);
 }
@@ -496,7 +496,7 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA
       STOP(_("'order' length (%d) is different to by='s length (%d)"), LENGTH(ascArg), LENGTH(by));
     SEXP recycleAscArg = PROTECT(allocVector(INTSXP, LENGTH(by))); n_protect++;
     for (int j=0; j<LENGTH(recycleAscArg); j++)
-      INTEGER(recycleAscArg)[j] = INTEGER(ascArg)[0];
+      INTEGER(recycleAscArg)[j] = INTEGER_RO(ascArg)[0];
     ascArg = recycleAscArg;
   }
   nrow = length(VECTOR_ELT(DT,0));
@@ -506,25 +506,25 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA
     if (by_i < 1 || by_i > length(DT))
       internal_error_with_cleanup(__func__, "'by' value %d out of range [1,%d]", by_i, length(DT)); // # nocov # R forderv already catch that using C colnamesInt
     if ( nrow != length(VECTOR_ELT(DT, by_i-1)) )
-      STOP(_("Column %d is length %d which differs from length of column 1 (%d), are you attempting to order by a list column?\n"), INTEGER(by)[i], length(VECTOR_ELT(DT, INTEGER(by)[i]-1)), nrow);
+      STOP(_("Column %d is length %d which differs from length of column 1 (%d), are you attempting to order by a list column?\n"), INTEGER_RO(by)[i], length(VECTOR_ELT(DT, INTEGER_RO(by)[i]-1)), nrow);
     if (TYPEOF(VECTOR_ELT(DT, by_i-1)) == CPLXSXP) n_cplx++;
   }
   if (!IS_TRUE_OR_FALSE(retGrpArg))
     STOP(_("retGrp must be TRUE or FALSE")); // # nocov # covered in reuseSorting forder
-  retgrp = LOGICAL(retGrpArg)[0]==TRUE;
+  retgrp = LOGICAL_RO(retGrpArg)[0]==TRUE;
   if (!IS_TRUE_OR_FALSE(retStatsArg))
     STOP(_("retStats must be TRUE or FALSE")); // # nocov # covered in reuseSorting forder
-  retstats = LOGICAL(retStatsArg)[0]==TRUE;
+  retstats = LOGICAL_RO(retStatsArg)[0]==TRUE;
   if (!retstats && retgrp)
     error(_("retStats must be TRUE whenever retGrp is TRUE")); // # nocov # covered in reuseSorting forder
   if (!IS_TRUE_OR_FALSE(sortGroupsArg))
     STOP(_("sort must be TRUE or FALSE")); // # nocov # covered in reuseSorting forder
-  sortType = LOGICAL(sortGroupsArg)[0]==TRUE;   // if sortType is 1, it is later flipped between +1/-1 according to ascArg. Otherwise ascArg is ignored when sortType==0
+  sortType = LOGICAL_RO(sortGroupsArg)[0]==TRUE;   // if sortType is 1, it is later flipped between +1/-1 according to ascArg. Otherwise ascArg is ignored when sortType==0
   if (!retgrp && !sortType)
     STOP(_("At least one of retGrp= or sort= must be TRUE"));
   if (!isLogical(naArg) || LENGTH(naArg) != 1)
     STOP(_("na.last must be logical TRUE, FALSE or NA of length 1")); // # nocov # covered in reuseSorting forder
-  nalast = (LOGICAL(naArg)[0] == NA_LOGICAL) ? -1 : LOGICAL(naArg)[0]; // 1=na last, 0=na first (default), -1=remove na
+  nalast = (LOGICAL_RO(naArg)[0] == NA_LOGICAL) ? -1 : LOGICAL_RO(naArg)[0]; // 1=na last, 0=na first (default), -1=remove na
 
   if (nrow==0) {
     // empty vector or 0-row DT is always sorted
@@ -553,8 +553,8 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA
   TEND(1)
   savetl_init();   // from now on use Error not error
 
-  int ncol=length(by);
-  int keyAlloc = (ncol+n_cplx)*8 + 1;         // +1 for NULL to mark end; calloc to initialize with NULLs
+  const int ncol=length(by);
+  const int keyAlloc = (ncol+n_cplx)*8 + 1;         // +1 for NULL to mark end; calloc to initialize with NULLs
   key = calloc(keyAlloc, sizeof(*key));  // needs to be before loop because part II relies on part I, column-by-column.
   if (!key)
     STOP(_("Unable to allocate %"PRIu64" bytes of working memory"), (uint64_t)keyAlloc*sizeof(*key));  // # nocov
@@ -568,19 +568,19 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA
   TEND(2);
   for (int col=0; col<ncol; col++) {
     // Rprintf(_("Finding range of column %d ...\n"), col);
-    SEXP x = VECTOR_ELT(DT,INTEGER(by)[col]-1);
+    SEXP x = VECTOR_ELT(DT,INTEGER_RO(by)[col]-1);
     uint64_t min=0, max=0;     // min and max of non-NA finite values
     int na_count=0, infnan_count=0;
     bool anynotascii=false, anynotutf8=false;
     if (sortType) {
-      sortType=INTEGER(ascArg)[col];  // if sortType!=0 (not first-appearance) then +1/-1 comes from ascArg.
+      sortType=INTEGER_RO(ascArg)[col];  // if sortType!=0 (not first-appearance) then +1/-1 comes from ascArg.
       if (sortType!=1 && sortType!=-1)
         STOP(_("Item %d of order (ascending/descending) is %d. Must be +1 or -1."), col+1, sortType);
     }
     //Rprintf(_("sortType = %d\n"), sortType);
     switch(TYPEOF(x)) {
     case INTSXP : case LGLSXP :  // TODO skip LGL and assume range [0,1]
-      range_i32(INTEGER(x), nrow, &min, &max, &na_count);
+      range_i32(INTEGER_RO(x), nrow, &min, &max, &na_count);
       break;
     case CPLXSXP : {
       // treat as if two separate columns of double
@@ -718,7 +718,7 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA
 
     switch(TYPEOF(x)) {
     case INTSXP : case LGLSXP : {
-      int32_t *xd = INTEGER(x);
+      const int32_t *xd = INTEGER_RO(x);
       #pragma omp parallel for num_threads(getDTthreads(nrow, true))
       for (int i=0; i<nrow; i++) {
         uint64_t elem=0;
@@ -733,7 +733,7 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA
       break;
     case REALSXP :
       if (inherits(x, "integer64")) {
-        int64_t *xd = (int64_t *)REAL(x);
+        const int64_t *xd = (const int64_t*)REAL_RO(x);
         #pragma omp parallel for num_threads(getDTthreads(nrow, true))
         for (int i=0; i<nrow; i++) {
           uint64_t elem=0;
@@ -746,7 +746,7 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA
           WRITE_KEY
         }
       } else {
-        double *xd = REAL(x);     // TODO: revisit double compression (skip bytes/mult by 10,100 etc) as currently it's often 6-8 bytes even for 3.14,3.15
+        const double *xd = REAL_RO(x);     // TODO: revisit double compression (skip bytes/mult by 10,100 etc) as currently it's often 6-8 bytes even for 3.14,3.15
         #pragma omp parallel for num_threads(getDTthreads(nrow, true))
         for (int i=0; i<nrow; i++) {
           uint64_t elem=0;
@@ -1402,8 +1402,8 @@ SEXP issorted(SEXP x, SEXP by)
   if (isVectorAtomic(x) || length(by)==1) {
     // one-column special case is very common so specialize it by avoiding column-type switches inside the row-loop later
     if (length(by)==1) {
-      if (INTEGER(by)[0]<1 || INTEGER(by)[0]>length(x)) STOP(_("issorted 'by' [%d] out of range [1,%d]"), INTEGER(by)[0], length(x));
-      x = VECTOR_ELT(x, INTEGER(by)[0]-1);
+      if (INTEGER(by)[0]<1 || INTEGER_RO(by)[0]>length(x)) STOP(_("issorted 'by' [%d] out of range [1,%d]"), INTEGER_RO(by)[0], length(x));
+      x = VECTOR_ELT(x, INTEGER_RO(by)[0]-1);
     }
     const int n = length(x);
     if (n <= 1) return(ScalarLogical(TRUE));
@@ -1416,10 +1416,10 @@ SEXP issorted(SEXP x, SEXP by)
     } break;
     case REALSXP :
       if (inherits(x,"integer64")) {
-        int64_t *xd = (int64_t *)REAL(x);
+        const int64_t *xd = (const int64_t*)REAL_RO(x);
         while (i<n && xd[i]>=xd[i-1]) i++;
       } else {
-        double *xd = REAL(x);
+        const double *xd = REAL_RO(x);
         while (i<n && dtwiddle(xd[i])>=dtwiddle(xd[i-1])) i++;  // TODO: change to loop over any NA or -Inf at the beginning and then proceed without dtwiddle() (but rounding)
       }
       break;
@@ -1459,11 +1459,11 @@ SEXP issorted(SEXP x, SEXP by)
     switch(TYPEOF(col)) {
     case INTSXP: case LGLSXP:
       types[j] = 0;
-      ptrs[j] = (const char *)INTEGER(col);
+      ptrs[j] = (const char *)INTEGER_RO(col);
       break;
     case REALSXP:
       types[j] = inherits(col, "integer64") ? 2 : 1;
-      ptrs[j] = (const char *)REAL(col);
+      ptrs[j] = (const char *)REAL_RO(col);
       break;
     case STRSXP:
       types[j] = 3;
@@ -1522,7 +1522,7 @@ SEXP isOrderedSubset(SEXP x, SEXP nrowArg)
   if (!isInteger(nrowArg) || LENGTH(nrowArg)!=1) error(_("nrow must be integer vector length 1"));
   const int nrow = INTEGER(nrowArg)[0];
   if (nrow<0) error(_("nrow==%d but must be >=0"), nrow);
-  const int *xd = INTEGER(x), xlen=LENGTH(x);
+  const int *xd = INTEGER_RO(x), xlen=LENGTH(x);
   for (int i=0, last=INT_MIN; i<xlen; ++i) {
     int elem = xd[i];
     if (elem==0) continue;
@@ -1560,7 +1560,7 @@ SEXP binary(SEXP x)
 static bool all1(SEXP x) {
   if (!isInteger(x))
     internal_error_with_cleanup(__func__, "all1 got non-integer"); // # nocov
-  int *xp = INTEGER(x);
+  const int *xp = INTEGER_RO(x);
   for (int i=0; i<LENGTH(x); ++i) if (xp[i] != 1) return false;
   return true;
 }
@@ -1578,7 +1578,7 @@ bool colsKeyHead(SEXP x, SEXP cols) {
   }
   SEXP keynames = PROTECT(chmatch(key, getAttrib(x, R_NamesSymbol), 0));
   UNPROTECT(1); // key
-  int *keynamesp = INTEGER(keynames), *colsp = INTEGER(cols);
+  const int *keynamesp = INTEGER_RO(keynames), *colsp = INTEGER_RO(cols);
   for (int i=0; i<LENGTH(cols); ++i) {
     if (colsp[i]!=keynamesp[i]) {
       UNPROTECT(1);
@@ -1649,7 +1649,7 @@ bool GetUseIndex(void) {
   SEXP opt = GetOption1(install("datatable.use.index"));
   if (!IS_TRUE_OR_FALSE(opt))
     error(_("'datatable.use.index' option must be TRUE or FALSE")); // # nocov
-  return LOGICAL(opt)[0];
+  return LOGICAL_RO(opt)[0];
 }
 
 // isTRUE(getOption("datatable.auto.index"))
@@ -1662,12 +1662,12 @@ bool GetAutoIndex(void) {
     return false;
   if (!IS_TRUE_OR_FALSE(opt))
     error(_("'datatable.forder.auto.index' option must be TRUE or FALSE")); // # nocov
-  return LOGICAL(opt)[0];
+  return LOGICAL_RO(opt)[0];
 }
 
 // attr(idx, "anyna")>0 || attr(idx, "anyinfnan")>0
 bool idxAnyNF(SEXP idx) {
-  return INTEGER(getAttrib(idx, sym_anyna))[0]>0 || INTEGER(getAttrib(idx, sym_anyinfnan))[0]>0;
+  return INTEGER_RO(getAttrib(idx, sym_anyna))[0]>0 || INTEGER_RO(getAttrib(idx, sym_anyinfnan))[0]>0;
 }
 
 // forder, re-use existing key or index if possible, otherwise call forder
@@ -1681,23 +1681,23 @@ SEXP forderReuseSorting(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP
     error(_("DT is NULL"));
   if (!IS_TRUE_OR_FALSE(retGrpArg))
     error(_("retGrp must be TRUE or FALSE"));
-  bool retGrp = (bool)LOGICAL(retGrpArg)[0];
+  bool retGrp = (bool)LOGICAL_RO(retGrpArg)[0];
   if (!IS_TRUE_OR_FALSE(retStatsArg))
     error(_("retStats must be TRUE or FALSE"));
-  bool retStats = (bool)LOGICAL(retStatsArg)[0];
+  bool retStats = (bool)LOGICAL_RO(retStatsArg)[0];
   if (!retStats && retGrp)
     error(_("retStats must be TRUE whenever retGrp is TRUE")); // retStats doesnt cost anything and it will be much easier to optimize use of index
   if (!IS_TRUE_OR_FALSE(sortGroupsArg))
     error(_("sort must be TRUE or FALSE"));
-  bool sortGroups = (bool)LOGICAL(sortGroupsArg)[0];
+  bool sortGroups = (bool)LOGICAL_RO(sortGroupsArg)[0];
   if (!isLogical(naArg) || LENGTH(naArg) != 1)
     error(_("na.last must be logical TRUE, FALSE or NA of length 1"));
-  bool na = (bool)LOGICAL(naArg)[0];
+  bool na = (bool)LOGICAL_RO(naArg)[0];
   if (!isInteger(ascArg))
     error(_("order must be integer")); // # nocov # coerced to int in R
   if (!isLogical(reuseSortingArg) || LENGTH(reuseSortingArg) != 1)
     error(_("reuseSorting must be logical TRUE, FALSE or NA of length 1"));
-  int reuseSorting = LOGICAL(reuseSortingArg)[0];
+  int reuseSorting = LOGICAL_RO(reuseSortingArg)[0];
   if (!length(DT))
     return allocVector(INTSXP, 0);
   int opt = -1; // -1=unknown, 0=none, 1=keyOpt, 2=idxOpt
diff --git a/src/frank.c b/src/frank.c
index 997ec79e4..35d8ccf83 100644
--- a/src/frank.c
+++ b/src/frank.c
@@ -28,12 +28,12 @@ SEXP dt_na(SEXP x, SEXP cols)
       error(_("Column %d of input list x is length %d, inconsistent with first column of that item which is length %d."), i+1,length(v),n);
     switch (TYPEOF(v)) {
     case LGLSXP: {
-      const int *iv = LOGICAL(v);
+      const int *iv = LOGICAL_RO(v);
       for (int j=0; j<n; ++j) ians[j] |= (iv[j] == NA_LOGICAL);
     }
       break;
     case INTSXP: {
-      const int *iv = INTEGER(v);
+      const int *iv = INTEGER_RO(v);
       for (int j=0; j<n; ++j) ians[j] |= (iv[j] == NA_INTEGER);
     }
       break;
@@ -44,10 +44,10 @@ SEXP dt_na(SEXP x, SEXP cols)
       break;
     case REALSXP: {
       if (INHERITS(v, char_integer64)) {
-        const int64_t *dv = (int64_t *)REAL(v);
+        const int64_t *dv = (const int64_t*)REAL_RO(v);
         for (int j=0; j<n; ++j) ians[j] |= (dv[j] == NA_INTEGER64);
       } else {
-        const double *dv = REAL(v);
+        const double *dv = REAL_RO(v);
         for (int j=0; j<n; ++j) ians[j] |= ISNAN(dv[j]);
       }
     }
@@ -59,7 +59,7 @@ SEXP dt_na(SEXP x, SEXP cols)
       break;
     case CPLXSXP: {
       // taken from https://github.com/wch/r-source/blob/d75f39d532819ccc8251f93b8ab10d5b83aac89a/src/main/coerce.c
-      for (int j=0; j<n; ++j) ians[j] |= (ISNAN(COMPLEX(v)[j].r) || ISNAN(COMPLEX(v)[j].i));
+      for (int j=0; j<n; ++j) ians[j] |= (ISNAN(COMPLEX_RO(v)[j].r) || ISNAN(COMPLEX_RO(v)[j].i));
     }
       break;
     case VECSXP: {
@@ -69,11 +69,11 @@ SEXP dt_na(SEXP x, SEXP cols)
         SEXP list_element = VECTOR_ELT(v, j);
         switch (TYPEOF(list_element)) {
         case LGLSXP: {
-          ians[j] |= (length(list_element)==1 && LOGICAL(list_element)[0] == NA_LOGICAL);
+          ians[j] |= (length(list_element)==1 && LOGICAL_RO(list_element)[0] == NA_LOGICAL);
         }
           break;
         case INTSXP: {
-          ians[j] |= (length(list_element)==1 && INTEGER(list_element)[0] == NA_INTEGER);
+          ians[j] |= (length(list_element)==1 && INTEGER_RO(list_element)[0] == NA_INTEGER);
         }
           break;
         case STRSXP: {
@@ -82,7 +82,7 @@ SEXP dt_na(SEXP x, SEXP cols)
           break;
         case CPLXSXP: {
           if (length(list_element)==1) {
-            Rcomplex first_complex = COMPLEX(list_element)[0];
+            Rcomplex first_complex = COMPLEX_RO(list_element)[0];
             ians[j] |= (ISNAN(first_complex.r) || ISNAN(first_complex.i));
           }
         }
@@ -90,9 +90,9 @@ SEXP dt_na(SEXP x, SEXP cols)
         case REALSXP: {
           if (length(list_element)==1) {
             if (INHERITS(list_element, char_integer64)) {
-              ians[j] |= ((const int64_t *)REAL(list_element))[0] == NA_INTEGER64;
+              ians[j] |= ((const int64_t *)REAL_RO(list_element))[0] == NA_INTEGER64;
             } else {
-              ians[j] |= ISNAN(REAL(list_element)[0]);
+              ians[j] |= ISNAN(REAL_RO(list_element)[0]);
             }
           }
         }
@@ -110,7 +110,7 @@ SEXP dt_na(SEXP x, SEXP cols)
 }
 
 SEXP frank(SEXP xorderArg, SEXP xstartArg, SEXP xlenArg, SEXP ties_method) {
-  const int *xstart = INTEGER(xstartArg), *xlen = INTEGER(xlenArg), *xorder = INTEGER(xorderArg);
+  const int *xstart = INTEGER_RO(xstartArg), *xlen = INTEGER_RO(xlenArg), *xorder = INTEGER_RO(xorderArg);
   enum {MEAN, MAX, MIN, DENSE, SEQUENCE, LAST} ties=0; // RUNLENGTH
 
   const char *pties = CHAR(STRING_ELT(ties_method, 0));
@@ -191,7 +191,7 @@ SEXP anyNA(SEXP x, SEXP cols) {
   if (!isNewList(x)) internal_error(__func__, "Argument '%s' to %s is type '%s' not '%s'", "x", "CanyNA", type2char(TYPEOF(x)), "list"); // #nocov
   if (!isInteger(cols)) internal_error(__func__, "Argument '%s' to %s is type '%s' not '%s'", "cols", "CanyNA", type2char(TYPEOF(cols)), "integer"); // # nocov
   for (int i=0; i<LENGTH(cols); ++i) {
-    const int elem = INTEGER(cols)[i];
+    const int elem = INTEGER_RO(cols)[i];
     if (elem<1 || elem>LENGTH(x))
       error(_("Item %d of 'cols' is %d which is outside 1-based range [1,ncol(x)=%d]"), i+1, elem, LENGTH(x));
     if (!n) n = length(VECTOR_ELT(x, elem-1));
@@ -205,11 +205,11 @@ SEXP anyNA(SEXP x, SEXP cols) {
     j=0;
     switch (TYPEOF(v)) {
     case LGLSXP: {
-      const int *iv = LOGICAL(v);
+      const int *iv = LOGICAL_RO(v);
       while(j<n && iv[j]!=NA_LOGICAL) j++;
     } break;
     case INTSXP: {
-      const int *iv = INTEGER(v);
+      const int *iv = INTEGER_RO(v);
       while(j<n && iv[j]!=NA_INTEGER) j++;
     } break;
     case STRSXP: {
@@ -218,10 +218,10 @@ SEXP anyNA(SEXP x, SEXP cols) {
     } break;
     case REALSXP:
       if (INHERITS(v, char_integer64)) {
-        const int64_t *dv = (int64_t *)REAL(v);
+        const int64_t *dv = (const int64_t*)REAL_RO(v);
         while (j<n && dv[j]!=NA_INTEGER64) j++;
       } else {
-        const double *dv = REAL(v);
+        const double *dv = REAL_RO(v);
         while (j<n && !ISNAN(dv[j])) j++;
       }
       break;
@@ -230,7 +230,7 @@ SEXP anyNA(SEXP x, SEXP cols) {
       j = n;
       break;
     case CPLXSXP: {
-      const Rcomplex *cv = COMPLEX(v);
+      const Rcomplex *cv = COMPLEX_RO(v);
       // taken from https://github.com/wch/r-source/blob/d75f39d532819ccc8251f93b8ab10d5b83aac89a/src/main/coerce.c
       while (j<n && !ISNAN(cv[j].r) && !ISNAN(cv[j].i)) j++;
     } break;
diff --git a/src/freadR.c b/src/freadR.c
index d586aaed0..7638982f1 100644
--- a/src/freadR.c
+++ b/src/freadR.c
@@ -80,8 +80,8 @@ SEXP freadR(
   SEXP noTZasUTC
 )
 {
-  verbose = LOGICAL(verboseArg)[0];
-  warningsAreErrors = LOGICAL(warnings2errorsArg)[0];
+  verbose = LOGICAL_RO(verboseArg)[0];
+  warningsAreErrors = LOGICAL_RO(warnings2errorsArg)[0];
 
   freadMainArgs args;
   ncol = 0;
@@ -92,7 +92,7 @@ SEXP freadR(
   const char *ch = (const char *)CHAR(STRING_ELT(inputArg, 0));
   if (!isLogical(isFileNameArg) || LENGTH(isFileNameArg) != 1 || LOGICAL(isFileNameArg)[0] == NA_LOGICAL)
     internal_error(__func__, "freadR isFileNameArg not TRUE or FALSE");  // # nocov
-  if (LOGICAL(isFileNameArg)[0]) {
+  if (LOGICAL_RO(isFileNameArg)[0]) {
     if (verbose) DTPRINT(_("freadR.c has been passed a filename: %s\n"), ch);
     args.filename = R_ExpandFileName(ch);  // for convenience so user doesn't have to call path.expand()
     args.input = NULL;
@@ -122,21 +122,21 @@ SEXP freadR(
   // header is the only boolean where NA is valid and means 'auto'.
   // LOGICAL in R is signed 32 bits with NA_LOGICAL==INT_MIN, currently.
   args.header = false;
-  if (LOGICAL(headerArg)[0] == NA_LOGICAL) args.header = NA_BOOL8;
-  else if (LOGICAL(headerArg)[0] == TRUE) args.header = true;
+  if (LOGICAL_RO(headerArg)[0] == NA_LOGICAL) args.header = NA_BOOL8;
+  else if (LOGICAL_RO(headerArg)[0] == TRUE) args.header = true;
 
   args.nrowLimit = INT64_MAX;
   if (!isReal(nrowLimitArg) || length(nrowLimitArg) != 1)
     internal_error(__func__, "nrows not a single real. R level catches this.");  // # nocov
-  if (R_FINITE(REAL(nrowLimitArg)[0]) && REAL(nrowLimitArg)[0] >= 0.0)
-    args.nrowLimit = (int64_t)(REAL(nrowLimitArg)[0]);
+  if (R_FINITE(REAL_RO(nrowLimitArg)[0]) && REAL_RO(nrowLimitArg)[0] >= 0.0)
+    args.nrowLimit = (int64_t)(REAL_RO(nrowLimitArg)[0]);
 
-  args.logical01 = LOGICAL(logical01Arg)[0];
-  args.logicalYN = LOGICAL(logicalYNArg)[0];
+  args.logical01 = LOGICAL_RO(logical01Arg)[0];
+  args.logicalYN = LOGICAL_RO(logicalYNArg)[0];
 
   {
     SEXP tt = PROTECT(GetOption1(sym_old_fread_datetime_character));
-    args.oldNoDateTime = oldNoDateTime = isLogical(tt) && LENGTH(tt)==1 && LOGICAL(tt)[0] == TRUE;
+    args.oldNoDateTime = oldNoDateTime = isLogical(tt) && LENGTH(tt)==1 && LOGICAL_RO(tt)[0] == TRUE;
     UNPROTECT(1);
   }
   args.skipNrow = -1;
@@ -157,19 +157,19 @@ SEXP freadR(
   args.NAstrings = NAstrings;
 
   // here we use bool and rely on fread at R level to check these do not contain NA_LOGICAL
-  args.stripWhite = LOGICAL(stripWhiteArg)[0];
-  args.skipEmptyLines = LOGICAL(skipEmptyLinesArg)[0];
+  args.stripWhite = LOGICAL_RO(stripWhiteArg)[0];
+  args.skipEmptyLines = LOGICAL_RO(skipEmptyLinesArg)[0];
   const char *commentStr = CHAR(STRING_ELT(commentCharArg, 0));
   args.comment = strlen(commentStr) == 0 ? '\0' : commentStr[0];
   args.fill = INTEGER(fillArg)[0];
-  args.showProgress = LOGICAL(showProgressArg)[0];
-  if (INTEGER(nThreadArg)[0] < 1)
-    error("nThread(%d)<1", INTEGER(nThreadArg)[0]); // # notranslate
-  args.nth = (uint32_t)INTEGER(nThreadArg)[0];
+  args.showProgress = LOGICAL_RO(showProgressArg)[0];
+  if (INTEGER_RO(nThreadArg)[0] < 1)
+    error("nThread(%d)<1", INTEGER_RO(nThreadArg)[0]); // # notranslate
+  args.nth = (uint32_t)INTEGER_RO(nThreadArg)[0];
   args.verbose = verbose;
   args.warningsAreErrors = warningsAreErrors;
-  args.keepLeadingZeros = LOGICAL(keepLeadingZerosArgs)[0];
-  args.noTZasUTC = LOGICAL(noTZasUTC)[0];
+  args.keepLeadingZeros = LOGICAL_RO(keepLeadingZerosArgs)[0];
+  args.noTZasUTC = LOGICAL_RO(noTZasUTC)[0];
 
   // === extras used for callbacks ===
   if (!isString(integer64Arg) || LENGTH(integer64Arg) != 1) error(_("'integer64' must be a single character string"));
@@ -395,7 +395,7 @@ bool userOverride(int8_t *type, lenOff *colNames, const char *anchor, const int
         else                 itemsInt = PROTECT(coerceVector(items, INTSXP));
         // UNPROTECTed directly just after this for loop. No nprotect++ here is correct.
         for (int j = 0; j < LENGTH(items); j++) {
-          const int colIdx = INTEGER(itemsInt)[j]; // NB: 1-based
+          const int colIdx = INTEGER_RO(itemsInt)[j]; // NB: 1-based
           if (colIdx == NA_INTEGER) {
             if (isString(items))
               DTWARN(_("Column name '%s' (colClasses[[%d]][%d]) not found"), CHAR(STRING_ELT(items, j)), i + 1, j + 1);
@@ -479,7 +479,7 @@ size_t allocateDT(int8_t *typeArg, int8_t *sizeArg, int ncolArg, int ndrop, size
     if (selectRank) {
       SEXP tt = PROTECT(allocVector(INTSXP, ncol - ndrop));
       int *ttD = INTEGER(tt), rank = 1;
-      const int *rankD = INTEGER(selectRank);
+      const int *rankD = INTEGER_RO(selectRank);
       for (int i = 0; i < ncol; i++) if (type[i] != CT_DROP) ttD[rankD[i] - 1] = rank++;
       SET_VECTOR_ELT(RCHK, 3, selectRank = tt);
       // selectRank now holds the order not the rank (so its name is now misleading). setFinalNRow passes it to setcolorder
diff --git a/src/frollR.c b/src/frollR.c
index 71963e6f8..50740eee9 100644
--- a/src/frollR.c
+++ b/src/frollR.c
@@ -36,9 +36,9 @@ SEXP coerceK(SEXP obj, bool adaptive) {
     } else {
       error(_("'n' must be an integer"));
     }
-    int nk = length(obj);
+    const int nk = length(obj);
     R_len_t i = 0;
-    int *iik = INTEGER(ans);
+    const int *iik = INTEGER_RO(ans);
     while (i < nk && iik[i] >= 0) i++;
     if (i != nk)
       error(_("'n' must be non-negative integer values (>= 0)"));
@@ -53,7 +53,7 @@ SEXP coerceK(SEXP obj, bool adaptive) {
         error(_("'n' must be an integer vector or list of integer vectors"));
       }
     } else {
-      int nk = length(obj);
+      const int nk = length(obj);
       ans = PROTECT(allocVector(VECSXP, nk)); protecti++;
       for (int i=0; i<nk; i++) {
         if (isInteger(VECTOR_ELT(obj, i))) {
@@ -65,9 +65,9 @@ SEXP coerceK(SEXP obj, bool adaptive) {
         }
       }
     }
-    int nx = length(VECTOR_ELT(ans, 0));
+    const int nx = length(VECTOR_ELT(ans, 0));
     for (int i=0; i<length(ans); i++) {
-      int *iik = INTEGER(VECTOR_ELT(ans, i));
+      const int *iik = INTEGER_RO(VECTOR_ELT(ans, i));
       R_len_t ii = 0;
       while (ii < nx && iik[ii] >= 0) ii++;
       if (ii != nx)
@@ -95,7 +95,7 @@ SEXP frollfunR(SEXP fun, SEXP xobj, SEXP kobj, SEXP fill, SEXP algo, SEXP align,
 
   if (!IS_TRUE_OR_FALSE(adaptive))
     error(_("%s must be TRUE or FALSE"), "adaptive");
-  bool badaptive = LOGICAL(adaptive)[0];
+  const bool badaptive = LOGICAL_RO(adaptive)[0];
 
   SEXP k = PROTECT(coerceK(kobj, badaptive)); protecti++;
   int nk = length(k);
@@ -113,7 +113,7 @@ SEXP frollfunR(SEXP fun, SEXP xobj, SEXP kobj, SEXP fill, SEXP algo, SEXP align,
 
   if (!isLogical(hasnf) || length(hasnf)!=1)
     error(_("has.nf must be TRUE, FALSE or NA"));
-  if (LOGICAL(hasnf)[0]==FALSE && LOGICAL(narm)[0])
+  if (LOGICAL_RO(hasnf)[0]==FALSE && LOGICAL_RO(narm)[0])
     error(_("using has.nf FALSE and na.rm TRUE does not make sense, if you know there are non-finite values then use has.nf TRUE, otherwise leave it as default NA"));
 
   int ialign=-2;                                                   // decode align to integer
@@ -175,15 +175,15 @@ SEXP frollfunR(SEXP fun, SEXP xobj, SEXP kobj, SEXP fill, SEXP algo, SEXP align,
     error(_("fill must be a vector of length 1"));
   if (!isInteger(fill) && !isReal(fill) && !isLogical(fill))
     error(_("fill must be numeric or logical"));
-  double dfill = REAL(PROTECT(coerceAs(fill, PROTECT(ScalarReal(NA_REAL)), ScalarLogical(true))))[0]; protecti++;
+  const double dfill = REAL_RO(PROTECT(coerceAs(fill, PROTECT(ScalarReal(NA_REAL)), ScalarLogical(true))))[0]; protecti++;
   UNPROTECT(1); // as= input to coerceAs()
 
-  bool bnarm = LOGICAL(narm)[0];
+  bool bnarm = LOGICAL_RO(narm)[0];
 
-  int ihasnf =                                                  // plain C tri-state boolean as integer
-    LOGICAL(hasnf)[0]==NA_LOGICAL ? 0 :                         // hasnf NA, default, no info about NA
-    LOGICAL(hasnf)[0]==TRUE ? 1 :                               // hasnf TRUE, might be some NAs
-    -1;                                                         // hasnf FALSE, there should be no NAs // or there must be no NAs for rollmax #5441
+  const int ihasnf =                                               // plain C tri-state boolean as integer
+    LOGICAL_RO(hasnf)[0]==NA_LOGICAL ? 0 :                         // hasnf NA, default, no info about NA
+    LOGICAL_RO(hasnf)[0]==TRUE ? 1 :                               // hasnf TRUE, might be some NAs
+    -1;                                                            // hasnf FALSE, there should be no NAs // or there must be no NAs for rollmax #5441
 
   unsigned int ialgo=-1;                                           // decode algo to integer
   if (!strcmp(CHAR(STRING_ELT(algo, 0)), "fast"))
@@ -193,7 +193,7 @@ SEXP frollfunR(SEXP fun, SEXP xobj, SEXP kobj, SEXP fill, SEXP algo, SEXP align,
   else
     internal_error(__func__, "invalid %s argument in %s function should have been caught earlier", "algo", "rolling"); // # nocov
 
-  bool par = nx*nk>1 && ialgo==0;
+  const bool par = nx*nk>1 && ialgo==0;
   if (verbose) {
     if (par) {
       Rprintf(_("%s: computing %d column(s) and %d window(s) in parallel\n"), __func__, nx, nk);
@@ -226,14 +226,14 @@ SEXP frollfunR(SEXP fun, SEXP xobj, SEXP kobj, SEXP fill, SEXP algo, SEXP align,
 // helper called from R to generate adaptive window for irregularly spaced time series
 SEXP frolladapt(SEXP xobj, SEXP kobj, SEXP partial) {
 
-  bool p = LOGICAL(partial)[0];
-  int n = INTEGER(kobj)[0];
+  const bool p = LOGICAL_RO(partial)[0];
+  const int n = INTEGER_RO(kobj)[0];
   if (n == NA_INTEGER)
     error(_("'n' must not have NAs"));
   if (n < 1L)
     error(_("'n' must be positive integer values (>= 1)"));
   const int *x = INTEGER_RO(xobj);
-  int64_t len = XLENGTH(xobj); // can be 0
+  const int64_t len = XLENGTH(xobj); // can be 0
 
   if (len && x[0] == NA_INTEGER)
     error(_("index provided to 'x' must: be sorted, have no duplicates, have no NAs")); // error text for consistency to the one below
diff --git a/src/fsort.c b/src/fsort.c
index c43d69eee..b58bb6cde 100644
--- a/src/fsort.c
+++ b/src/fsort.c
@@ -96,7 +96,8 @@ int qsort_cmp(const void *a, const void *b) {
   return (x<y)-(x>y);   // largest first in a safe branchless way casting long to int
 }
 
-static size_t shrinkMSB(size_t MSBsize, uint64_t *msbCounts, int *order, Rboolean verbose) {
+static size_t shrinkMSB(size_t MSBsize, const uint64_t msbCounts[], const int order[], Rboolean verbose)
+{
   size_t oldMSBsize = MSBsize;
   while (MSBsize>0 && msbCounts[order[MSBsize-1]] < 2)
     MSBsize--;
@@ -115,7 +116,7 @@ SEXP fsort(SEXP x, SEXP verboseArg) {
   t[0] = wallclock();
   if (!IS_TRUE_OR_FALSE(verboseArg))
     error(_("%s must be TRUE or FALSE"), "verbose");
-  int verbose = LOGICAL(verboseArg)[0];
+  const int verbose = LOGICAL_RO(verboseArg)[0];
   if (!isNumeric(x)) error(_("x must be a vector of type double currently"));
   // TODO: not only detect if already sorted, but if it is, just return x to save the duplicate
 
diff --git a/src/fwriteR.c b/src/fwriteR.c
index 9cf870a35..7161b4e28 100644
--- a/src/fwriteR.c
+++ b/src/fwriteR.c
@@ -49,7 +49,7 @@ int getMaxCategLen(SEXP col) {
 
 const char *getCategString(SEXP col, int64_t row) {
   // the only writer that needs to have the header of the SEXP column, to get to the levels
-  int x = INTEGER(col)[row];
+  int x = INTEGER_RO(col)[row];
   return x == NA_INTEGER ? NULL : ENCODED_CHAR(STRING_ELT(getAttrib(col, R_LevelsSymbol), x - 1));
 }
 
@@ -75,7 +75,7 @@ static int32_t whichWriter(SEXP);
 
 void writeList(const void *col, int64_t row, char **pch) {
   SEXP v = ((const SEXP*)col)[row];
-  int32_t wf = whichWriter(v);
+  const int32_t wf = whichWriter(v);
   if (TYPEOF(v) == VECSXP || wf == INT32_MIN || isFactor(v)) {
     internal_error(__func__, "TYPEOF(v)!=VECSXP && wf!=INT32_MIN && !isFactor(v); getMaxListItem should have caught this up front");  // # nocov
   }
@@ -179,12 +179,12 @@ SEXP fwriteR(
   if (!isNewList(DF)) error(_("fwrite must be passed an object of type list; e.g. data.frame, data.table"));
 
   fwriteMainArgs args = { 0 };  // { 0 } to quieten valgrind's uninitialized, #4639
-  args.is_gzip = LOGICAL(is_gzip_Arg)[0];
-  args.gzip_level = INTEGER(gzip_level_Arg)[0];
-  args.bom = LOGICAL(bom_Arg)[0];
+  args.is_gzip = LOGICAL_RO(is_gzip_Arg)[0];
+  args.gzip_level = INTEGER_RO(gzip_level_Arg)[0];
+  args.bom = LOGICAL_RO(bom_Arg)[0];
   args.yaml = CHAR(STRING_ELT(yaml_Arg, 0));
-  args.verbose = LOGICAL(verbose_Arg)[0];
-  args.forceDecimal = LOGICAL(forceDecimal_Arg)[0];
+  args.verbose = LOGICAL_RO(verbose_Arg)[0];
+  args.forceDecimal = LOGICAL_RO(forceDecimal_Arg)[0];
   args.filename = CHAR(STRING_ELT(filename_Arg, 0));
   args.ncol = length(DF);
   if (args.ncol == 0) {
@@ -195,7 +195,7 @@ SEXP fwriteR(
 
   SEXP DFcoerced = DF;
   int protecti = 0;
-  dateTimeAs = INTEGER(dateTimeAs_Arg)[0];
+  dateTimeAs = INTEGER_RO(dateTimeAs_Arg)[0];
   if (dateTimeAs == DATETIMEAS_WRITECSV) {
     int i = 0;
     while(i < args.ncol && !INHERITS(VECTOR_ELT(DF,i), char_POSIXct)) i++;
@@ -232,9 +232,9 @@ SEXP fwriteR(
 
   // just for use at this level to control whichWriter() when called now for each column and
   // when called later for cell items of list columns (if any)
-  dateTimeAs = INTEGER(dateTimeAs_Arg)[0];
-  logical01 = LOGICAL(logical01_Arg)[0];
-  args.scipen = INTEGER(scipen_Arg)[0];
+  dateTimeAs = INTEGER_RO(dateTimeAs_Arg)[0];
+  logical01 = LOGICAL_RO(logical01_Arg)[0];
+  args.scipen = INTEGER_RO(scipen_Arg)[0];
   utf8 = !strcmp(CHAR(STRING_ELT(encoding_Arg, 0)), "UTF-8");
   native = !strcmp(CHAR(STRING_ELT(encoding_Arg, 0)), "native");
 
@@ -254,18 +254,18 @@ SEXP fwriteR(
   }
 
   SEXP cn = getAttrib(DF, R_NamesSymbol);
-  args.colNames = (LOGICAL(colNames_Arg)[0] && isString(cn)) ? DATAPTR_RO(cn) : NULL;
+  args.colNames = (LOGICAL_RO(colNames_Arg)[0] && isString(cn)) ? DATAPTR_RO(cn) : NULL;
 
   // user may want row names even when they don't exist (implied row numbers as row names)
   // so we need a separate boolean flag as well as the row names should they exist (rare)
-  args.doRowNames = LOGICAL(rowNames_Arg)[0];
+  args.doRowNames = LOGICAL_RO(rowNames_Arg)[0];
   args.rowNames = NULL;
   args.rowNameFun = 0;
   if (args.doRowNames) {
     SEXP rn = PROTECT(getAttrib(DF, R_RowNamesSymbol));
     protecti++;
     if (isInteger(rn)) {
-      if (xlength(rn) != 2 || INTEGER(rn)[0] == NA_INTEGER) {
+      if (xlength(rn) != 2 || INTEGER_RO(rn)[0] == NA_INTEGER) {
         // not R's default rownames c(NA,-nrow)
         if (xlength(rn) != args.nrow)
            // Use (long long) to cast R_xlen_t to a fixed type to robustly avoid -Wformat compiler warnings, see #5768, PRId64 didn't work on M1
@@ -302,13 +302,13 @@ SEXP fwriteR(
 
   args.eol = CHAR(STRING_ELT(eol_Arg, 0));
   args.na = CHAR(STRING_ELT(na_Arg, 0));
-  args.doQuote = LOGICAL(quote_Arg)[0] == NA_LOGICAL ? INT8_MIN : LOGICAL(quote_Arg)[0] == 1;
-  args.qmethodEscape = LOGICAL(qmethodEscape_Arg)[0] == 1;
+  args.doQuote = LOGICAL_RO(quote_Arg)[0] == NA_LOGICAL ? INT8_MIN : LOGICAL_RO(quote_Arg)[0] == 1;
+  args.qmethodEscape = LOGICAL_RO(qmethodEscape_Arg)[0] == 1;
   args.squashDateTime = (dateTimeAs == 1);
-  args.append = LOGICAL(append_Arg)[0];
-  args.buffMB = INTEGER(buffMB_Arg)[0];
-  args.nth = INTEGER(nThread_Arg)[0];
-  args.showProgress = LOGICAL(showProgress_Arg)[0];
+  args.append = LOGICAL_RO(append_Arg)[0];
+  args.buffMB = INTEGER_RO(buffMB_Arg)[0];
+  args.nth = INTEGER_RO(nThread_Arg)[0];
+  args.showProgress = LOGICAL_RO(showProgress_Arg)[0];
 
   fwriteMain(args);
 
diff --git a/src/gsumm.c b/src/gsumm.c
index 5970f5919..1b0cc417e 100644
--- a/src/gsumm.c
+++ b/src/gsumm.c
@@ -2,9 +2,9 @@
 //#include <time.h>
 
 static int ngrp = 0;         // number of groups
-static int *grpsize = NULL;  // size of each group, used by gmean (and gmedian) not gsum
+static const int *grpsize = NULL;  // size of each group, used by gmean (and gmedian) not gsum
 static int nrow = 0;         // length of underlying x; same as length(ghigh) and length(glow)
-static int *irows;           // GForce support for subsets in 'i' (TODO: joins in 'i')
+static const int *irows;           // GForce support for subsets in 'i' (TODO: joins in 'i')
 static int irowslen = -1;    // -1 is for irows = NULL
 static uint16_t *high=NULL, *low=NULL;  // the group of each x item; a.k.a. which-group-am-I
 static int *restrict grp;    // TODO: eventually this can be made local for gforce as won't be needed globally when all functions here use gather
@@ -55,7 +55,7 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
     irowslen = -1;
   }
   else if (isInteger(irowsArg)) {
-    irows = INTEGER(irowsArg);
+    irows = INTEGER_RO(irowsArg);
     irowslen = LENGTH(irowsArg);
   }
   else error(_("irowsArg is neither an integer vector nor NULL"));  // # nocov
@@ -63,7 +63,7 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
   if (LENGTH(f) != ngrp)
     error("length(f)=%d != length(l)=%d", LENGTH(f), ngrp); // # notranslate
   nrow=0;
-  grpsize = INTEGER(l);
+  grpsize = INTEGER_RO(l);
   maxgrpn = 0;
   for (int i=0; i<ngrp; i++) {
     nrow+=grpsize[i];
@@ -72,7 +72,7 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
   if (LENGTH(o) && LENGTH(o)!=nrow) error(_("o has length %d but sum(l)=%d"), LENGTH(o), nrow);
   {
     SEXP tt = getAttrib(o, install("maxgrpn"));
-    if (length(tt)==1 && INTEGER(tt)[0]!=maxgrpn) internal_error(__func__, "o's maxgrpn attribute mismatches recalculated maxgrpn"); // # nocov
+    if (length(tt)==1 && INTEGER_RO(tt)[0]!=maxgrpn) internal_error(__func__, "o's maxgrpn attribute mismatches recalculated maxgrpn"); // # nocov
   }
 
   int nb = nbit(ngrp-1);
@@ -112,7 +112,7 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
     //  for (int j=0; j<grpsize[g]; j++)  grp[ elem[j]-1 ] = g;
     //}
 
-    const int *restrict op = INTEGER(o);  // o is a permutation of 1:nrow
+    const int *restrict op = INTEGER_RO(o);  // o is a permutation of 1:nrow
     int nb = nbit(nrow-1);
     int bitshift = MAX(nb-8, 0);  // TODO: experiment nb/2.  Here it doesn't have to be /2 currently.
     int highSize = ((nrow-1)>>bitshift) + 1;
@@ -349,7 +349,7 @@ SEXP gsum(SEXP x, SEXP narmArg)
 {
   if (!IS_TRUE_OR_FALSE(narmArg))
     error(_("%s must be TRUE or FALSE"), "na.rm");
-  const bool narm = LOGICAL(narmArg)[0];
+  const bool narm = LOGICAL_RO(narmArg)[0];
   if (inherits(x, "factor"))
     error(_("%s is not meaningful for factors."), "sum");
   const int n = (irowslen == -1) ? length(x) : irowslen;
@@ -585,7 +585,7 @@ SEXP gmean(SEXP x, SEXP narmArg)
     error(_("%s is not meaningful for factors."), "mean");
   if (!IS_TRUE_OR_FALSE(narmArg))
     error(_("%s must be TRUE or FALSE"), "na.rm");
-  const bool narm = LOGICAL(narmArg)[0];
+  const bool narm = LOGICAL_RO(narmArg)[0];
   const int n = (irowslen == -1) ? length(x) : irowslen;
   double started = wallclock();
   const bool verbose=GetVerbose();
@@ -744,7 +744,7 @@ static SEXP gminmax(SEXP x, SEXP narm, const bool min)
   case LGLSXP: case INTSXP: {
     ans = PROTECT(allocVector(INTSXP, ngrp));
     int *ansd = INTEGER(ans);
-    const int *xd = INTEGER(x);
+    const int *xd = INTEGER_RO(x);
     if (!LOGICAL(narm)[0]) {
       const int init = min ? INT_MAX : INT_MIN+1;  // NA_INTEGER==INT_MIN checked in init.c
       for (int i=0; i<ngrp; ++i) ansd[i] = init;
@@ -770,7 +770,7 @@ static SEXP gminmax(SEXP x, SEXP narm, const bool min)
     ans = PROTECT(allocVector(STRSXP, ngrp));
     const SEXP *ansd = STRING_PTR_RO(ans);
     const SEXP *xd = STRING_PTR_RO(x);
-    if (!LOGICAL(narm)[0]) {
+    if (!LOGICAL_RO(narm)[0]) {
       const SEXP init = min ? char_maxString : R_BlankString;  // char_maxString == "\xFF\xFF..." in init.c
       for (int i=0; i<ngrp; ++i) SET_STRING_ELT(ans, i, init);
       for (int i=0; i<n; ++i) {
@@ -795,8 +795,8 @@ static SEXP gminmax(SEXP x, SEXP narm, const bool min)
     ans = PROTECT(allocVector(REALSXP, ngrp));
     if (INHERITS(x, char_integer64)) {
       int64_t *ansd = (int64_t *)REAL(ans);
-      const int64_t *xd = (const int64_t *)REAL(x);
-      if (!LOGICAL(narm)[0]) {
+      const int64_t *xd = (const int64_t *)REAL_RO(x);
+      if (!LOGICAL_RO(narm)[0]) {
         const int64_t init = min ? INT64_MAX : INT64_MIN+1;
         for (int i=0; i<ngrp; ++i) ansd[i] = init;
         for (int i=0; i<n; ++i) {
@@ -818,8 +818,8 @@ static SEXP gminmax(SEXP x, SEXP narm, const bool min)
       }
     } else {
       double *ansd = REAL(ans);
-      const double *xd = REAL(x);
-      if (!LOGICAL(narm)[0]) {
+      const double *xd = REAL_RO(x);
+      if (!LOGICAL_RO(narm)[0]) {
         const double init = min ? R_PosInf : R_NegInf;
         for (int i=0; i<ngrp; ++i) ansd[i] = init;
         for (int i=0; i<n; ++i) {
@@ -881,8 +881,8 @@ SEXP gmedian(SEXP x, SEXP narmArg) {
   switch(TYPEOF(x)) {
   case REALSXP: {
     double *subd = REAL(PROTECT(allocVector(REALSXP, maxgrpn))); // allocate once upfront and reuse
-    int64_t *xi64 = (int64_t *)REAL(x);
-    double  *xd = REAL(x);
+    const int64_t *xi64 = (const int64_t*)REAL_RO(x);
+    const double *xd = REAL_RO(x);
     for (int i=0; i<ngrp; ++i) {
       int thisgrpsize = grpsize[i], nacount=0;
       for (int j=0; j<thisgrpsize; ++j) {
@@ -898,7 +898,7 @@ SEXP gmedian(SEXP x, SEXP narmArg) {
     break;
   case LGLSXP: case INTSXP: {
     int *subi = INTEGER(PROTECT(allocVector(INTSXP, maxgrpn)));
-    int *xi = INTEGER(x);
+    const int *xi = INTEGER_RO(x);
     for (int i=0; i<ngrp; i++) {
       const int thisgrpsize = grpsize[i];
       int nacount=0;
@@ -976,6 +976,7 @@ static SEXP gfirstlast(SEXP x, const bool first, const int w, const bool headw)
       internal_error(__func__, "unanticipated case first=%d w=%d headw=%d", first, w, headw);      \
     }                                                                                              \
   }
+
   switch(TYPEOF(x)) {
   case LGLSXP:  { int      *ansd=LOGICAL(ans); DO(int,      LOGICAL, NA_LOGICAL,   ansd[ansi++]=val) } break;
   case INTSXP:  { int      *ansd=INTEGER(ans); DO(int,      INTEGER, NA_INTEGER,   ansd[ansi++]=val) } break;
@@ -1003,19 +1004,19 @@ SEXP gfirst(SEXP x) {
 
 SEXP gtail(SEXP x, SEXP nArg) {
   if (!isInteger(nArg) || LENGTH(nArg)!=1 || INTEGER(nArg)[0]<1) internal_error(__func__, "gtail is only implemented for n>0. This should have been caught before"); // # nocov
-  const int n=INTEGER(nArg)[0];
+  const int n=INTEGER_RO(nArg)[0];
   return n==1 ? glast(x) : gfirstlast(x, false, n, true);
 }
 
 SEXP ghead(SEXP x, SEXP nArg) {
   if (!isInteger(nArg) || LENGTH(nArg)!=1 || INTEGER(nArg)[0]<1) internal_error(__func__, "gtail is only implemented for n>0. This should have been caught before"); // # nocov
-  const int n=INTEGER(nArg)[0];
+  const int n=INTEGER_RO(nArg)[0];
   return n==1 ? gfirst(x) : gfirstlast(x, true, n, true);
 }
 
 SEXP gnthvalue(SEXP x, SEXP nArg) {
   if (!isInteger(nArg) || LENGTH(nArg)!=1 || INTEGER(nArg)[0]<1) internal_error(__func__, "`g[` (gnthvalue) is only implemented single value subsets with positive index, e.g., .SD[2]. This should have been caught before"); // # nocov
-  return gfirstlast(x, true, INTEGER(nArg)[0], false);
+  return gfirstlast(x, true, INTEGER_RO(nArg)[0], false);
 }
 
 // TODO: gwhich.min, gwhich.max
@@ -1032,12 +1033,12 @@ static SEXP gvarsd1(SEXP x, SEXP narmArg, bool isSD)
   SEXP sub, ans = PROTECT(allocVector(REALSXP, ngrp));
   double *ansd = REAL(ans);
   const bool nosubset = irowslen==-1;
-  const bool narm = LOGICAL(narmArg)[0];
+  const bool narm = LOGICAL_RO(narmArg)[0];
   switch(TYPEOF(x)) {
   case LGLSXP: case INTSXP: {
     sub = PROTECT(allocVector(INTSXP, maxgrpn)); // allocate once upfront
     int *subd = INTEGER(sub);
-    const int *xd = INTEGER(x);
+    const int *xd = INTEGER_RO(x);
     for (int i=0; i<ngrp; ++i) {
       const int thisgrpsize = grpsize[i];
       if (thisgrpsize==1) {
@@ -1068,7 +1069,7 @@ static SEXP gvarsd1(SEXP x, SEXP narmArg, bool isSD)
   case REALSXP: {
     sub = PROTECT(allocVector(REALSXP, maxgrpn)); // allocate once upfront
     double *subd = REAL(sub);
-    const double *xd = REAL(x);
+    const double *xd = REAL_RO(x);
     for (int i=0; i<ngrp; ++i) {
       const int thisgrpsize = grpsize[i];
       if (thisgrpsize==1) {
@@ -1131,7 +1132,7 @@ SEXP gprod(SEXP x, SEXP narmArg) {
   for (int i=0; i<ngrp; ++i) s[i] = 1.0;
   switch(TYPEOF(x)) {
   case LGLSXP: case INTSXP: {
-    const int *xd = INTEGER(x);
+    const int *xd = INTEGER_RO(x);
     for (int i=0; i<n; ++i) {
       const int thisgrp = grp[i];
       const int elem = nosubset ? xd[i] : (irows[i]==NA_INTEGER ? NA_INTEGER : xd[irows[i]-1]);
@@ -1144,7 +1145,7 @@ SEXP gprod(SEXP x, SEXP narmArg) {
     break;
   case REALSXP: {
     if (INHERITS(x, char_integer64)) {
-      const int64_t *xd = (const int64_t *)REAL(x);
+      const int64_t *xd = (const int64_t*)REAL_RO(x);
       for (int i=0; i<n; ++i) {
         const int thisgrp = grp[i];
         const int64_t elem = nosubset ? xd[i] : (irows[i]==NA_INTEGER ? NA_INTEGER64 : xd[irows[i]-1]);
@@ -1155,7 +1156,7 @@ SEXP gprod(SEXP x, SEXP narmArg) {
         s[thisgrp] *= elem;
       }
     } else {
-      const double *xd = REAL(x);
+      const double *xd = REAL_RO(x);
       for (int i=0; i<n; ++i) {
         const int thisgrp = grp[i];
         const double elem = nosubset ? xd[i] : (irows[i]==NA_INTEGER ? NA_REAL : xd[irows[i]-1]);
@@ -1217,7 +1218,7 @@ SEXP gshift(SEXP x, SEXP nArg, SEXP fillArg, SEXP typeArg) {
   R_xlen_t nk = length(nArg);
   if (!isInteger(nArg))
     internal_error(__func__, "n must be integer"); // # nocov
-  const int *kd = INTEGER(nArg);
+  const int *kd = INTEGER_RO(nArg);
   for (int i=0; i<nk; i++) if (kd[i]==NA_INTEGER) error(_("Item %d of n is NA"), i+1);
 
   SEXP ans = PROTECT(allocVector(VECSXP, nk)); nprotect++;
diff --git a/src/ijoin.c b/src/ijoin.c
index e81e8325f..6c704cdc8 100644
--- a/src/ijoin.c
+++ b/src/ijoin.c
@@ -9,9 +9,9 @@
 SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP multArg, SEXP typeArg, SEXP verbose) {
 
   SEXP vv, tt, lookup, type_lookup;
-  R_len_t *idx,*count,*type_count,xrows=INTEGER(xlen)[0],uxrows=LENGTH(VECTOR_ELT(ux, 0)),uxcols=LENGTH(ux);
-  int *from = INTEGER(VECTOR_ELT(indices, 0));
-  int *to   = INTEGER(VECTOR_ELT(indices, 1));
+  R_len_t *idx,*count,*type_count,xrows=INTEGER_RO(xlen)[0],uxrows=LENGTH(VECTOR_ELT(ux, 0)),uxcols=LENGTH(ux);
+  const int *from = INTEGER_RO(VECTOR_ELT(indices, 0));
+  const int *to = INTEGER_RO(VECTOR_ELT(indices, 1));
   clock_t pass1, pass2, pass3, start;
   enum {ALL, FIRST, LAST} mult = ALL;
   enum {ANY, WITHIN, START, END, EQUAL} type = ANY;
@@ -124,7 +124,7 @@ SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP mul
   default: internal_error(__func__, "unknown mult: %d", mult); // # nocov
   }
   pass1 = clock() - start;
-  if (LOGICAL(verbose)[0])
+  if (LOGICAL_RO(verbose)[0])
     Rprintf(_("First pass on calculating lengths in lookup ... done in %8.3f seconds\n"), 1.0*(pass1)/CLOCKS_PER_SEC);
   // second pass: allocate vectors
   start = clock();
@@ -137,7 +137,7 @@ SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP mul
     }
   }
   pass2 = clock() - start;
-  if (LOGICAL(verbose)[0])
+  if (LOGICAL_RO(verbose)[0])
     Rprintf(_("Second pass on allocation in lookup ... done in %8.3f seconds\n"), 1.0*(pass2)/CLOCKS_PER_SEC);
   // generate lookup
   start = clock();
@@ -169,7 +169,7 @@ SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP mul
         vv = VECTOR_ELT(lookup, i);
         tt = VECTOR_ELT(type_lookup, i);
         if (length(tt) && length(vv)) {            // length check added by Matt to avoid SEGV in #2767
-          INTEGER(tt)[0] = INTEGER(vv)[0];
+          INTEGER(tt)[0] = INTEGER_RO(vv)[0];
         }
       }
       break;
@@ -180,7 +180,7 @@ SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP mul
         vv = VECTOR_ELT(lookup, i);
         tt = VECTOR_ELT(type_lookup, i);
         if (length(tt) && length(vv)>=count[i]) {   // length check added by Matt to avoid SEGV in #2767
-          INTEGER(tt)[0] = INTEGER(vv)[count[i]-1];
+          INTEGER(tt)[0] = INTEGER_RO(vv)[count[i]-1];
         }
       }
 
@@ -197,7 +197,7 @@ SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP mul
           tt = VECTOR_ELT(type_lookup, i);
           int k=0;
           for (int j=count[i]-type_count[i]; j<count[i]; ++j)
-            INTEGER(tt)[k++] = INTEGER(vv)[j];
+            INTEGER(tt)[k++] = INTEGER_RO(vv)[j];
         }
         break;
 
@@ -216,7 +216,7 @@ SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP mul
     }
   }
   pass3 = clock() - start;
-  if (LOGICAL(verbose)[0])
+  if (LOGICAL_RO(verbose)[0])
     Rprintf(_("Final step in generating lookup ... done in %8.3f seconds\n"), 1.0*(pass3)/CLOCKS_PER_SEC);
   return(R_NilValue);
 }
@@ -224,11 +224,11 @@ SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP mul
 SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchArg, SEXP verbose) {
 
   R_len_t uxcols=LENGTH(ux),rows=length(VECTOR_ELT(imatches,0));
-  int nomatch = INTEGER(nomatchArg)[0], totlen=0, thislen;
-  int *from   = INTEGER(VECTOR_ELT(imatches, 0));
-  int *to     = INTEGER(VECTOR_ELT(imatches, 1));
-  int *count   = INTEGER(VECTOR_ELT(ux, uxcols-2));
-  int *type_count   = INTEGER(VECTOR_ELT(ux, uxcols-1));
+  int nomatch = INTEGER_RO(nomatchArg)[0], totlen=0, thislen;
+  const int *from   = INTEGER_RO(VECTOR_ELT(imatches, 0));
+  const int *to     = INTEGER_RO(VECTOR_ELT(imatches, 1));
+  const int *count  = INTEGER_RO(VECTOR_ELT(ux, uxcols-2));
+  const int *type_count   = INTEGER_RO(VECTOR_ELT(ux, uxcols-1));
   SEXP lookup = VECTOR_ELT(ux, uxcols-4);
   SEXP type_lookup = VECTOR_ELT(ux, uxcols-3);
   SEXP ans, f1__, f2__, tmp1, tmp2;
@@ -271,9 +271,9 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
           tmp1 = VECTOR_ELT(lookup, k-1);
           tmp2 = VECTOR_ELT(type_lookup, to[i]-1);
           while (j<count[k-1] && m<type_count[to[i]-1]) {
-            if ( INTEGER(tmp1)[j] == INTEGER(tmp2)[m] ) {
+            if ( INTEGER(tmp1)[j] == INTEGER_RO(tmp2)[m] ) {
               ++wlen; ++j; ++m;
-            } else if ( INTEGER(tmp1)[j] > INTEGER(tmp2)[m] ) {
+            } else if ( INTEGER_RO(tmp1)[j] > INTEGER_RO(tmp2)[m] ) {
               ++m;
             } else ++j;
           }
@@ -310,9 +310,9 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
             tmp1 = VECTOR_ELT(lookup, k-1);
             tmp2 = VECTOR_ELT(lookup, to[i]-1);
             while (j<count[k-1] && m<count[to[i]-1]) {
-              if ( INTEGER(tmp1)[j] == INTEGER(tmp2)[m] ) {
+              if ( INTEGER_RO(tmp1)[j] == INTEGER_RO(tmp2)[m] ) {
                 ++totlen; ++j; ++m;
-              } else if ( INTEGER(tmp1)[j] > INTEGER(tmp2)[m] ) {
+              } else if ( INTEGER_RO(tmp1)[j] > INTEGER_RO(tmp2)[m] ) {
                 ++m;
               } else ++j;
             }
@@ -326,7 +326,7 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
     }
   } else totlen = rows;
   end1 = clock() - start;
-  if (LOGICAL(verbose)[0])
+  if (LOGICAL_RO(verbose)[0])
     Rprintf(_("First pass on calculating lengths in overlaps ... done in %8.3f seconds\n"), 1.0*(end1)/CLOCKS_PER_SEC);
 
   // ans[0] is the the position of 'query' and ans[1] is that of 'subject'
@@ -351,7 +351,7 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
           tmp2 = VECTOR_ELT(type_lookup, k-1);
           for (int j=0; j<type_count[k-1]; ++j) {
             INTEGER(f1__)[thislen] = i+1;
-            INTEGER(f2__)[thislen] = INTEGER(tmp2)[j];
+            INTEGER(f2__)[thislen] = INTEGER_RO(tmp2)[j];
             ++thislen;
           }
         }
@@ -373,7 +373,7 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
             tmp2 = VECTOR_ELT(type_lookup, to[i]-1);
             for (int j=0; j<count[k-1]; ++j) {
               INTEGER(f1__)[thislen] = i+1;
-              INTEGER(f2__)[thislen] = INTEGER(tmp1)[j];
+              INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[j];
               ++thislen;
             }
           } else if (k < to[i]) {
@@ -381,11 +381,11 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
             tmp1 = VECTOR_ELT(lookup, k-1);
             tmp2 = VECTOR_ELT(type_lookup, to[i]-1);
             while (j<count[k-1] && m<type_count[to[i]-1]) {
-              if ( INTEGER(tmp1)[j] == INTEGER(tmp2)[m] ) {
+              if ( INTEGER_RO(tmp1)[j] == INTEGER_RO(tmp2)[m] ) {
                 INTEGER(f1__)[thislen] = i+1;
-                INTEGER(f2__)[thislen] = INTEGER(tmp1)[j];
+                INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[j];
                  ++thislen; ++j; ++m;
-               } else if ( INTEGER(tmp1)[j] > INTEGER(tmp2)[m] ) {
+               } else if ( INTEGER_RO(tmp1)[j] > INTEGER_RO(tmp2)[m] ) {
                  ++m;
                } else ++j;
              }
@@ -408,7 +408,7 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
           tmp1 = VECTOR_ELT(lookup, k-1);
           for (int m=0; m<count[k-1]; ++m) {
             INTEGER(f1__)[thislen] = i+1;
-            INTEGER(f2__)[thislen] = INTEGER(tmp1)[m];
+            INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[m];
             ++thislen;
           }
         }
@@ -416,7 +416,7 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
           tmp2 = VECTOR_ELT(type_lookup, j-1);
           for (int m=0; m<type_count[j-1]; ++m) {
             INTEGER(f1__)[thislen] = i+1;
-            INTEGER(f2__)[thislen] = INTEGER(tmp2)[m];
+            INTEGER(f2__)[thislen] = INTEGER_RO(tmp2)[m];
             ++thislen;
           }
         }
@@ -438,7 +438,7 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
             tmp1 = VECTOR_ELT(lookup, k-1);
             for (int j=0; j<count[k-1]; ++j) {
               INTEGER(f1__)[thislen] = i+1;
-              INTEGER(f2__)[thislen] = INTEGER(tmp1)[j];
+              INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[j];
               ++thislen;
             }
           } else if (k < to[i]) {
@@ -446,11 +446,11 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
             tmp1 = VECTOR_ELT(lookup, k-1);
             tmp2 = VECTOR_ELT(lookup, to[i]-1);
             while (j<count[k-1] && m<count[to[i]-1]) {
-              if ( INTEGER(tmp1)[j] == INTEGER(tmp2)[m] ) {
+              if ( INTEGER_RO(tmp1)[j] == INTEGER_RO(tmp2)[m] ) {
                 INTEGER(f1__)[thislen] = i+1;
-                INTEGER(f2__)[thislen] = INTEGER(tmp1)[j];
+                INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[j];
                  ++thislen; ++j; ++m;
-               } else if ( INTEGER(tmp1)[j] > INTEGER(tmp2)[m] ) {
+               } else if ( INTEGER_RO(tmp1)[j] > INTEGER_RO(tmp2)[m] ) {
                  ++m;
                } else ++j;
              }
@@ -476,7 +476,7 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
         const int k = (from[i]>0) ? from[i] : 1;
         if (k <= to[i]) { // count[k-1] is equal to type_count[k-1] and will always be >0, so no length check necessary.
           tmp1 = VECTOR_ELT(lookup, k-1);
-          INTEGER(f2__)[thislen] = INTEGER(tmp1)[0];
+          INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[0];
           ++thislen;
         }
         if (len == thislen) {
@@ -494,18 +494,18 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
           const int k = from[i];
           if (k == to[i]) {
             tmp1 = VECTOR_ELT(lookup, k-1);
-            INTEGER(f2__)[thislen] = INTEGER(tmp1)[0];
+            INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[0];
             ++thislen;
           } else if (k < to[i]) {
             int j=0, m=0;
             tmp1 = VECTOR_ELT(lookup, k-1);
             tmp2 = VECTOR_ELT(type_lookup, to[i]-1);
             while (j<count[k-1] && m<type_count[to[i]-1]) {
-              if ( INTEGER(tmp1)[j] == INTEGER(tmp2)[m] ) {
-                INTEGER(f2__)[thislen] = INTEGER(tmp1)[j];
+              if ( INTEGER_RO(tmp1)[j] == INTEGER_RO(tmp2)[m] ) {
+                INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[j];
                  ++thislen; ++j; ++m;
                  break;
-               } else if ( INTEGER(tmp1)[j] > INTEGER(tmp2)[m] ) {
+               } else if (INTEGER_RO(tmp1)[j] > INTEGER_RO(tmp2)[m]) {
                  ++m;
                } else ++j;
              }
@@ -527,7 +527,7 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
         for (int j=k; j<=to[i]; ++j) {
           if (type_count[j-1]) {
             tmp2 = VECTOR_ELT(type_lookup, j-1);
-            INTEGER(f2__)[thislen] = INTEGER(tmp2)[0];
+            INTEGER(f2__)[thislen] = INTEGER_RO(tmp2)[0];
             ++thislen;
             break;
           }
@@ -547,18 +547,18 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
         if (k > 0) {
           if (k == to[i] && count[k-1]) {
             tmp1 = VECTOR_ELT(lookup, k-1);
-            INTEGER(f2__)[thislen] = INTEGER(tmp1)[0];
+            INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[0];
             ++thislen;
           } else if (k < to[i]) {
             int j=0, m=0;
             tmp1 = VECTOR_ELT(lookup, k-1);
             tmp2 = VECTOR_ELT(lookup, to[i]-1);
             while (j<count[k-1] && m<count[to[i]-1]) {
-              if ( INTEGER(tmp1)[j] == INTEGER(tmp2)[m] ) {
-                INTEGER(f2__)[thislen] = INTEGER(tmp1)[j];
+              if ( INTEGER_RO(tmp1)[j] == INTEGER_RO(tmp2)[m] ) {
+                INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[j];
                  ++thislen; ++j; ++m;
                  break;
-               } else if ( INTEGER(tmp1)[j] > INTEGER(tmp2)[m] ) {
+               } else if ( INTEGER_RO(tmp1)[j] > INTEGER_RO(tmp2)[m] ) {
                  ++m;;
                } else ++j;
              }
@@ -583,7 +583,7 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
         const int k = (from[i]>0) ? from[i] : 1;
         if (k <= to[i]) { // count[k-1] is equal to type_count[k-1] and will always be >0, so no length check necessary.
           tmp1 = VECTOR_ELT(lookup, k-1);
-          INTEGER(f2__)[thislen] = INTEGER(tmp1)[count[k-1]-1];
+          INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[count[k-1]-1];
           ++thislen;
         }
         if (len == thislen) {
@@ -609,18 +609,18 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
           const int k = from[i];
           if (k == to[i]) {
             tmp1 = VECTOR_ELT(lookup, k-1);
-            INTEGER(f2__)[thislen] = INTEGER(tmp1)[count[k-1]-1];
+            INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[count[k-1]-1];
             ++thislen;
           } else if (k < to[i]) {
             tmp1 = VECTOR_ELT(lookup, k-1);
             tmp2 = VECTOR_ELT(type_lookup, to[i]-1);
             int j=count[k-1]-1, m=type_count[to[i]-1]-1; // bug fix, k=from[i] but should be to[i]
             while (j>=0 && m>=0) {
-              if ( INTEGER(tmp1)[j] == INTEGER(tmp2)[m] ) {
-                INTEGER(f2__)[thislen] = INTEGER(tmp1)[j];
+              if (INTEGER_RO(tmp1)[j] == INTEGER_RO(tmp2)[m]) {
+                INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[j];
                  ++thislen; --j; --m;
                  break;
-               } else if ( INTEGER(tmp1)[j] < INTEGER(tmp2)[m] ) {
+               } else if (INTEGER_RO(tmp1)[j] < INTEGER_RO(tmp2)[m]) {
                  --m;
                } else --j;
              }
@@ -664,19 +664,19 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
         if (k <= to[i]) {
           if (k==to[i] && count[k-1]) {
             tmp1 = VECTOR_ELT(lookup, k-1);
-            INTEGER(f2__)[thislen] = INTEGER(tmp1)[count[k-1]-1];
+            INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[count[k-1]-1];
             ++thislen;
           } else {
             for (int j=to[i]; j>k; --j) {
               if (type_count[j-1]) {
                 tmp2 = VECTOR_ELT(type_lookup, j-1);
-                INTEGER(f2__)[thislen] = INTEGER(tmp2)[0]; // tmp2 will be length 1
+                INTEGER(f2__)[thislen] = INTEGER_RO(tmp2)[0]; // tmp2 will be length 1
                 ++thislen; break;
               }
             }
             if (len == thislen && count[k-1]) {
               tmp1 = VECTOR_ELT(lookup, k-1);
-              INTEGER(f2__)[thislen] = INTEGER(tmp1)[count[k-1]-1];
+              INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[count[k-1]-1];
               ++thislen;
             }
           }
@@ -696,18 +696,18 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
         if (k > 0) {
           if (k == to[i] && count[k-1]) {
             tmp1 = VECTOR_ELT(lookup, k-1);
-            INTEGER(f2__)[thislen] = INTEGER(tmp1)[count[k-1]-1];
+            INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[count[k-1]-1];
             ++thislen;
           } else if (k < to[i]) {
             tmp1 = VECTOR_ELT(lookup, k-1);
             tmp2 = VECTOR_ELT(lookup, to[i]-1);
             int j=count[k-1]-1, m=count[to[i]-1]-1;
             while (j>=0 && m>=0) {
-              if ( INTEGER(tmp1)[j] == INTEGER(tmp2)[m] ) {
-                INTEGER(f2__)[thislen] = INTEGER(tmp1)[j];
+              if ( INTEGER_RO(tmp1)[j] == INTEGER_RO(tmp2)[m] ) {
+                INTEGER(f2__)[thislen] = INTEGER_RO(tmp1)[j];
                  ++thislen; --j; --m;
                  break;
-               } else if ( INTEGER(tmp1)[j] < INTEGER(tmp2)[m] ) {
+               } else if ( INTEGER_RO(tmp1)[j] < INTEGER_RO(tmp2)[m] ) {
                  --m;
                } else --j;
              }
@@ -725,7 +725,7 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
   default: internal_error(__func__, "unknown mult: %d", mult); // # nocov
   }
   end2 = clock() - start;
-  if (LOGICAL(verbose)[0])
+  if (LOGICAL_RO(verbose)[0])
     Rprintf(_("Final step, fetching indices in overlaps ... done in %8.3f seconds\n"), 1.0*(end2)/CLOCKS_PER_SEC);
   UNPROTECT(1);
   return(ans);
diff --git a/src/init.c b/src/init.c
index ef81a7a0e..96a05ff98 100644
--- a/src/init.c
+++ b/src/init.c
@@ -339,9 +339,9 @@ inline double LLtoD(long long x) {
 int GetVerbose(void) {
   // don't call repetitively; save first in that case
   SEXP opt = GetOption1(sym_verbose);
-  if ((!isLogical(opt) && !isInteger(opt)) || LENGTH(opt)!=1 || INTEGER(opt)[0]==NA_INTEGER)
+  if ((!isLogical(opt) && !isInteger(opt)) || LENGTH(opt)!=1 || INTEGER_RO(opt)[0]==NA_INTEGER)
     error(_("verbose option must be length 1 non-NA logical or integer"));
-  return INTEGER(opt)[0];
+  return INTEGER_RO(opt)[0];
 }
 
 // # nocov start
diff --git a/src/mergelist.c b/src/mergelist.c
index 51f28d224..8b16ba191 100644
--- a/src/mergelist.c
+++ b/src/mergelist.c
@@ -7,7 +7,7 @@ SEXP copyCols(SEXP x, SEXP cols) {
     internal_error(__func__, "'x' must be a data.table"); // # nocov
   if (!isInteger(cols))
     internal_error(__func__, "'cols' must be integer"); // # nocov
-  int nx = length(x), ncols = LENGTH(cols), *colsp = INTEGER(cols);
+  const int nx = length(x), ncols = LENGTH(cols), *colsp = INTEGER_RO(cols);
   if (!nx || !ncols)
     return R_NilValue;
   for (int i=0; i<ncols; ++i) {
@@ -34,7 +34,7 @@ void mergeIndexAttrib(SEXP to, SEXP from) {
 SEXP cbindlist(SEXP x, SEXP copyArg) {
   if (!isNewList(x) || isDataFrame(x))
     error(_("'%s' must be a list"), "x");
-  bool copy = (bool)LOGICAL(copyArg)[0];
+  const bool copy = (bool)LOGICAL_RO(copyArg)[0];
   const bool verbose = GetVerbose();
   double tic = 0;
   if (verbose)
diff --git a/src/nafill.c b/src/nafill.c
index 5c9568efb..7189d79e0 100644
--- a/src/nafill.c
+++ b/src/nafill.c
@@ -103,13 +103,13 @@ SEXP nafillR(SEXP obj, SEXP type, SEXP fill, SEXP nan_is_na_arg, SEXP inplace, S
   if (verbose)
     tic = omp_get_wtime();
 
-  bool binplace = LOGICAL(inplace)[0];
+  const bool binplace = LOGICAL_RO(inplace)[0];
   if (!IS_TRUE_OR_FALSE(nan_is_na_arg))
     error(_("%s must be TRUE or FALSE"), "nan_is_na"); // # nocov
-  bool nan_is_na = LOGICAL(nan_is_na_arg)[0];
+  const bool nan_is_na = LOGICAL_RO(nan_is_na_arg)[0];
 
   SEXP x = R_NilValue;
-  bool obj_scalar = isVectorAtomic(obj);
+  const bool obj_scalar = isVectorAtomic(obj);
   if (obj_scalar) {
     if (binplace)
       error(_("'x' argument is atomic vector, in-place update is supported only for list/data.table"));
@@ -121,7 +121,7 @@ SEXP nafillR(SEXP obj, SEXP type, SEXP fill, SEXP nan_is_na_arg, SEXP inplace, S
   }
   SEXP ricols = PROTECT(colnamesInt(obj, cols, /* check_dups= */ ScalarLogical(TRUE), /* skip_absent= */ ScalarLogical(FALSE))); protecti++; // nafill cols=NULL which turns into seq_along(obj)
   x = PROTECT(allocVector(VECSXP, length(ricols))); protecti++;
-  int *icols = INTEGER(ricols);
+  const int *icols = INTEGER_RO(ricols);
   for (int i=0; i<length(ricols); i++) {
     SEXP this_col = VECTOR_ELT(obj, icols[i]-1);
     if (!isReal(this_col) && !isInteger(this_col))
diff --git a/src/openmp-utils.c b/src/openmp-utils.c
index a0cdec536..bde7ebfd4 100644
--- a/src/openmp-utils.c
+++ b/src/openmp-utils.c
@@ -79,11 +79,11 @@ static const char *mygetenv(const char *name, const char *unset)
 
 SEXP getDTthreads_C(SEXP n, SEXP throttle)
 {
-  if(!isInteger(n) || INTEGER(n)[0] < 0)
+  if(!isInteger(n) || INTEGER_RO(n)[0] < 0)
     internal_error(__func__, "n must be non-negative integer");  // # nocov
   if(!IS_TRUE_OR_FALSE(throttle))
     internal_error(__func__, "throttle must be TRUE or FALSE");  // # nocov
-  return ScalarInteger(getDTthreads(INTEGER(n)[0], LOGICAL(throttle)[0]));
+  return ScalarInteger(getDTthreads(INTEGER_RO(n)[0], LOGICAL_RO(throttle)[0]));
 }
 
 SEXP getDTthreads_R(SEXP verbose)
@@ -121,12 +121,12 @@ SEXP setDTthreads(SEXP threads, SEXP restore_after_fork, SEXP percent, SEXP thro
     if (!isLogical(restore_after_fork) || LOGICAL(restore_after_fork)[0] == NA_LOGICAL) {
       error(_("restore_after_fork= must be TRUE, FALSE, or NULL (default). getDTthreads(verbose=TRUE) reports the current setting.\n"));
     }
-    RestoreAfterFork = LOGICAL(restore_after_fork)[0];  // # nocov
+    RestoreAfterFork = LOGICAL_RO(restore_after_fork)[0];  // # nocov
   }
   if (length(throttle)) {
-    if (!isInteger(throttle) || LENGTH(throttle) != 1 || INTEGER(throttle)[0] < 1)
+    if (!isInteger(throttle) || LENGTH(throttle) != 1 || INTEGER_RO(throttle)[0] < 1)
       error(_("'throttle' must be a single number, non-NA, and >=1"));
-    DTthrottle = INTEGER(throttle)[0];
+    DTthrottle = INTEGER_RO(throttle)[0];
   }
   int old = DTthreads;
   if (!length(threads) && !length(throttle)) {
@@ -138,11 +138,11 @@ SEXP setDTthreads(SEXP threads, SEXP restore_after_fork, SEXP percent, SEXP thro
     // reflect that and a call to setDTthreads(threads=NULL) will update DTthreads.
   } else if (length(threads)) {
     int n = 0;
-    if (length(threads) != 1 || !isInteger(threads) || (n = INTEGER(threads)[0]) < 0) {  // <0 catches NA too since NA is negative (INT_MIN)
+    if (length(threads) != 1 || !isInteger(threads) || (n = INTEGER_RO(threads)[0]) < 0) {  // <0 catches NA too since NA is negative (INT_MIN)
       error(_("threads= must be either NULL or a single number >= 0. See ?setDTthreads."));
     }
     int num_procs = imax(omp_get_num_procs(), 1); // max just in case omp_get_num_procs() returns <= 0 (perhaps error, or unsupported)
-    if (!isLogical(percent) || length(percent) != 1 || LOGICAL(percent)[0] == NA_LOGICAL) {
+    if (!isLogical(percent) || length(percent) != 1 || LOGICAL_RO(percent)[0] == NA_LOGICAL) {
       internal_error(__func__, "percent= must be TRUE or FALSE at C level");  // # nocov
     }
     if (LOGICAL(percent)[0]) {
diff --git a/src/shellsort.c b/src/shellsort.c
index 47a4fcf41..2c7fe50d1 100644
--- a/src/shellsort.c
+++ b/src/shellsort.c
@@ -12,17 +12,20 @@ ciura2001 = function(k) if (k==1) 1 else if (k==2) 4 else if (k==3) 10 else if (
 # Lee 2021
 lee = function(k, y=2.243609061420001) tokuda(k, y=y)
 */
-static const int sedgewick1982[17] = {
-  1073790977, 268460033, 67121153, 16783361, 4197377, 1050113,
-  262913, 65921, 16577, 4193, 1073, 281, 77, 23, 8, 1, 0
-};
-#define NGAPS 16
 
 /* shellsort
  * uses sedgewick1982 gap sequence formula as it turned out to be the most efficient - tested various n, k (for rnorm only!)
  * currently used in frollmedian algo="fast" when no NAs
 */
 void shellsort(const double *x, int n, int *o) {
+
+  static const int sedgewick1982[17] = {
+    1073790977, 268460033, 67121153, 16783361, 4197377, 1050113,
+    262913, 65921, 16577, 4193, 1073, 281, 77, 23, 8, 1, 0
+  };
+
+  static const int NGAPS = 16;
+  
   for (int i=0; i < n; i++) o[i] = i;
   int gap = 0;
   while (sedgewick1982[gap] > n) gap++;
diff --git a/src/shift.c b/src/shift.c
index 1ddc3549b..62e29e3a9 100644
--- a/src/shift.c
+++ b/src/shift.c
@@ -30,7 +30,7 @@ SEXP shift(SEXP obj, SEXP k, SEXP fill, SEXP type)
 
   int nx = length(x), nk = length(k);
   if (!isInteger(k)) internal_error(__func__, "k must be integer"); // # nocov
-  const int *kd = INTEGER(k);
+  const int *kd = INTEGER_RO(k);
   for (int i=0; i<nk; i++) if (kd[i]==NA_INTEGER) error(_("Item %d of n is NA"), i+1);  // NA crashed (#3354); n is called k at C level
 
   const bool cycle = stype == CYCLIC;
@@ -49,14 +49,14 @@ SEXP shift(SEXP obj, SEXP k, SEXP fill, SEXP type)
     SEXP thisfill = PROTECT(coerceAs(fill, elem, ScalarLogical(0)));  // #4865 use coerceAs for type coercion
     switch (TYPEOF(elem)) {
     case INTSXP: case LGLSXP: {
-      const int ifill = INTEGER(thisfill)[0];
+      const int ifill = INTEGER_RO(thisfill)[0];
       for (int j=0; j<nk; j++) {
         SEXP tmp;
         SET_VECTOR_ELT(ans, i*nk+j, tmp=allocVector(TYPEOF(elem), xrows) );
-        const int *restrict ielem = INTEGER(elem);
+        const int *restrict ielem = INTEGER_RO(elem);
         int *restrict itmp = INTEGER(tmp);
-        size_t thisk = cycle ? abs(kd[j]) % xrows : MIN(abs(kd[j]), xrows);
-        size_t tailk = xrows-thisk;
+        const size_t thisk = cycle ? abs(kd[j]) % xrows : MIN(abs(kd[j]), xrows);
+        const size_t tailk = xrows-thisk;
         if (((stype == LAG || stype == CYCLIC) && kd[j] >= 0) || (stype == LEAD && kd[j] < 0)) {
           // LAG when type %in% c('lag','cyclic') and n >= 0 _or_ type = 'lead' and n < 0
           if (tailk > 0) memmove(itmp+thisk, ielem, tailk*size);
@@ -75,11 +75,11 @@ SEXP shift(SEXP obj, SEXP k, SEXP fill, SEXP type)
       }
     } break;
     case REALSXP : {
-      const double dfill = REAL(thisfill)[0];
+      const double dfill = REAL_RO(thisfill)[0];
       for (int j=0; j<nk; j++) {
         SEXP tmp;
         SET_VECTOR_ELT(ans, i*nk+j, tmp=allocVector(REALSXP, xrows) );
-        const double *restrict delem = REAL(elem);
+        const double *restrict delem = REAL_RO(elem);
         double *restrict dtmp = REAL(tmp);
         size_t thisk = cycle ? abs(kd[j]) % xrows : MIN(abs(kd[j]), xrows);
         size_t tailk = xrows-thisk;
@@ -98,11 +98,11 @@ SEXP shift(SEXP obj, SEXP k, SEXP fill, SEXP type)
       }
     } break;
     case CPLXSXP : {
-      const Rcomplex cfill = COMPLEX(thisfill)[0];
+      const Rcomplex cfill = COMPLEX_RO(thisfill)[0];
       for (int j=0; j<nk; j++) {
         SEXP tmp;
         SET_VECTOR_ELT(ans, i*nk+j, tmp=allocVector(CPLXSXP, xrows) );
-        const Rcomplex *restrict celem = COMPLEX(elem);
+        const Rcomplex *restrict celem = COMPLEX_RO(elem);
         Rcomplex *restrict ctmp = COMPLEX(tmp);
         size_t thisk = cycle ? abs(kd[j]) % xrows : MIN(abs(kd[j]), xrows);
         size_t tailk = xrows-thisk;
@@ -151,11 +151,11 @@ SEXP shift(SEXP obj, SEXP k, SEXP fill, SEXP type)
       }
     } break;
     case RAWSXP : {
-      const Rbyte rfill = RAW(thisfill)[0];
+      const Rbyte rfill = RAW_RO(thisfill)[0];
       for (int j=0; j<nk; j++) {
         SEXP tmp;
         SET_VECTOR_ELT(ans, i*nk+j, tmp=allocVector(RAWSXP, xrows) );
-        const Rbyte *restrict delem = RAW(elem);
+        const Rbyte *restrict delem = RAW_RO(elem);
         Rbyte *restrict dtmp = RAW(tmp);
         size_t thisk = cycle ? abs(kd[j]) % xrows : MIN(abs(kd[j]), xrows);
         size_t tailk = xrows-thisk;
diff --git a/src/subset.c b/src/subset.c
index 1dd9f5f17..20e1638a6 100644
--- a/src/subset.c
+++ b/src/subset.c
@@ -6,7 +6,7 @@ void subsetVectorRaw(SEXP ans, SEXP source, SEXP idx, const bool anyNA)
   const int n = length(idx);
   if (length(ans)!=n) internal_error(__func__, "length(ans)==%d n=%d", length(ans), n); // # nocov
 
-  const int *restrict idxp = INTEGER(idx);
+  const int *restrict idxp = INTEGER_RO(idx);
   // anyNA refers to NA _in idx_; if there's NA in the data (source) that's just regular data to be copied
   // negatives, zeros and out-of-bounds have already been dealt with in convertNegAndZero so we can rely
   // here on idx in range [1,length(ans)].
@@ -110,7 +110,7 @@ const char *check_idx(SEXP idx, int max, bool *anyNA_out, bool *orderedSubset_ou
   if (!isInteger(idx)) internal_error(__func__, "Argument '%s' to %s is type '%s' not '%s'", "idx", "check_idx", type2char(TYPEOF(idx)), "integer"); // # nocov
   bool anyLess=false, anyNA=false;
   int last = INT32_MIN;
-  int *idxp = INTEGER(idx), n=LENGTH(idx);
+  const int *idxp = INTEGER_RO(idx), n=LENGTH(idx);
   for (int i=0; i<n; i++) {
     int elem = idxp[i];
     if (elem<=0 && elem!=NA_INTEGER) return "Internal inefficiency: idx contains negatives or zeros. Should have been dealt with earlier.";  // e.g. test 762  (TODO-fix)
@@ -136,16 +136,16 @@ SEXP convertNegAndZeroIdx(SEXP idx, SEXP maxArg, SEXP allowOverMax, SEXP allowNA
     internal_error(__func__, "'idx' is type '%s' not 'integer'", type2char(TYPEOF(idx))); // # nocov
   if (!isInteger(maxArg) || length(maxArg)!=1)
     internal_error(__func__, "'maxArg' is type '%s' and length %d, should be an integer singleton", type2char(TYPEOF(maxArg)), length(maxArg)); // # nocov
-  if (!isLogical(allowOverMax) || LENGTH(allowOverMax)!=1 || LOGICAL(allowOverMax)[0]==NA_LOGICAL)
+  if (!isLogical(allowOverMax) || LENGTH(allowOverMax)!=1 || LOGICAL_RO(allowOverMax)[0]==NA_LOGICAL)
     internal_error(__func__, "allowOverMax must be TRUE/FALSE");  // # nocov
-  const int max = INTEGER(maxArg)[0], n=LENGTH(idx);
+  const int max = INTEGER_RO(maxArg)[0], n=LENGTH(idx);
   if (max<0)
     internal_error(__func__, "max is %d, must be >= 0.", max); // # nocov    includes NA which will print as INT_MIN
-  if (!isLogical(allowNAArg) || LENGTH(allowNAArg)!=1 || LOGICAL(allowNAArg)[0]==NA_LOGICAL)
+  if (!isLogical(allowNAArg) || LENGTH(allowNAArg)!=1 || LOGICAL_RO(allowNAArg)[0]==NA_LOGICAL)
     internal_error(__func__, "allowNAArg must be TRUE/FALSE");  // # nocov
-  const bool allowNA = LOGICAL(allowNAArg)[0];
+  const bool allowNA = LOGICAL_RO(allowNAArg)[0];
 
-  const int *idxp = INTEGER(idx);
+  const int *idxp = INTEGER_RO(idx);
   bool stop = false;
   #pragma omp parallel for num_threads(getDTthreads(n, true))
   for (int i=0; i<n; ++i) {
@@ -291,9 +291,10 @@ SEXP subsetDT(SEXP x, SEXP rows, SEXP cols) { // API change needs update NEWS.md
   }
 
   if (!isInteger(cols)) internal_error(__func__, "Argument '%s' to %s is type '%s' not '%s'", "cols", "Csubset", type2char(TYPEOF(cols)), "integer"); // # nocov
+  
+  const int *this = INTEGER_RO(cols);
   for (int i=0; i<LENGTH(cols); i++) {
-    int this = INTEGER(cols)[i];
-    if (this<1 || this>LENGTH(x)) error(_("Item %d of cols is %d which is outside the range [1,ncol(x)=%d]"), i+1, this, LENGTH(x));
+    if (this[i]<1 || this[i]>LENGTH(x)) error(_("Item %d of cols is %d which is outside the range [1,ncol(x)=%d]"), i+1, this[i], LENGTH(x));
   }
 
   int overAlloc = checkOverAlloc(GetOption1(install("datatable.alloccol")));
@@ -310,7 +311,7 @@ SEXP subsetDT(SEXP x, SEXP rows, SEXP cols) { // API change needs update NEWS.md
   int ansn;
   if (isNull(rows)) {
     ansn = nrow;
-    const int *colD = INTEGER(cols);
+    const int *colD = INTEGER_RO(cols);
     for (int i=0; i<LENGTH(cols); i++) {
       SEXP thisCol = VECTOR_ELT(x, colD[i]-1);
       checkCol(thisCol, colD[i], nrow, x);
@@ -319,7 +320,7 @@ SEXP subsetDT(SEXP x, SEXP rows, SEXP cols) { // API change needs update NEWS.md
     }
   } else {
     ansn = LENGTH(rows);  // has been checked not to contain zeros or negatives, so this length is the length of result
-    const int *colD = INTEGER(cols);
+    const int *colD = INTEGER_RO(cols);
     for (int i=0; i<LENGTH(cols); i++) {
       SEXP source = VECTOR_ELT(x, colD[i]-1);
       checkCol(source, colD[i], nrow, x);
diff --git a/src/utils.c b/src/utils.c
index b159fa0e6..abf8a524c 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -59,7 +59,7 @@ bool allNA(SEXP x, bool errorForBadType) {
     return false;
   case LGLSXP:
   case INTSXP: {
-    const int *xd = INTEGER(x);
+    const int *xd = INTEGER_RO(x);
     for (int i=0; i<n; ++i)    if (xd[i]!=NA_INTEGER) {
       return false;
     }
@@ -67,19 +67,19 @@ bool allNA(SEXP x, bool errorForBadType) {
   }
   case REALSXP:
     if (INHERITS(x, char_integer64)) {
-      const int64_t *xd = (int64_t *)REAL(x);
+      const int64_t *xd = (const int64_t *)REAL_RO(x);
       for (int i=0; i<n; ++i)  if (xd[i]!=NA_INTEGER64) {
         return false;
       }
     } else {
-      const double *xd = REAL(x);
+      const double *xd = REAL_RO(x);
       for (int i=0; i<n; ++i)  if (!ISNAN(xd[i])) {
         return false;
       }
     }
     return true;
   case CPLXSXP: {
-    const Rcomplex *xd = COMPLEX(x);
+    const Rcomplex *xd = COMPLEX_RO(x);
     for (int i=0; i<n; ++i) if (!ISNAN_COMPLEX(xd[i])) {
       return false;
     }
@@ -121,7 +121,7 @@ SEXP colnamesInt(SEXP x, SEXP cols, SEXP check_dups, SEXP skip_absent) {
   int protecti = 0;
   R_len_t nx = length(x);
   R_len_t nc = length(cols);
-  bool bskip_absent = LOGICAL(skip_absent)[0];
+  bool bskip_absent = LOGICAL_RO(skip_absent)[0];
   SEXP ricols = R_NilValue;
   if (isNull(cols)) { // seq_along(x)
     ricols = PROTECT(allocVector(INTSXP, nx)); protecti++;
@@ -162,7 +162,7 @@ SEXP colnamesInt(SEXP x, SEXP cols, SEXP check_dups, SEXP skip_absent) {
   } else {
     error(_("argument specifying columns must be character or numeric"));
   }
-  if (LOGICAL(check_dups)[0] && any_duplicated(ricols, FALSE))
+  if (LOGICAL_RO(check_dups)[0] && any_duplicated(ricols, FALSE))
     error(_("argument specifying columns received duplicate column(s)"));
   UNPROTECT(protecti);
   return ricols;
diff --git a/src/vecseq.c b/src/vecseq.c
index 4a940bc9b..a781b4e46 100644
--- a/src/vecseq.c
+++ b/src/vecseq.c
@@ -16,8 +16,8 @@ SEXP vecseq(SEXP x, SEXP len, SEXP clamp)
     error(_("len must be an integer vector")); // # nocov
   if (LENGTH(x) != LENGTH(len))
     error(_("x and len must be the same length")); // # nocov
-  const int *ix = INTEGER(x);
-  const int *ilen = INTEGER(len), nlen=LENGTH(len);
+  const int *ix = INTEGER_RO(x);
+  const int *ilen = INTEGER_RO(len), nlen=LENGTH(len);
   int reslen = 0;
   for (int i=0; i<nlen; ++i) {
     if (INT_MAX-reslen < ilen[i])