From 5e24debbd956c353aaa6f9675af76a72bb41c1d6 Mon Sep 17 00:00:00 2001
From: Joshua Ulrich <josh.m.ulrich@gmail.com>
Date: Mon, 6 Mar 2023 18:25:15 -0600
Subject: [PATCH] Add support for long vectors (> 2^32-1)

R added support for long vectors in version 3.0.0. The xts C code had
not been updated to take advantage of this feature. That meant xts
objects were limited to matrices with less than 2^32-1 elements.

Most of the changes are fall into these categories:

    1. Change index counters from 'int' to 'R_xlen_t'
    2. Use xlength() instead of LENGTH() or length() to get length
    3. Use xlengthgets() instead of lengthgets() to set length

There are a few non-functional changes to move type declaration closer
to where the variable is used.

See #239.
---
 inst/include/xts.h      |  2 +-
 src/any.c               |  4 ++--
 src/binsearch.c         | 24 ++++++++++++------------
 src/coredata.c          | 16 ++++++++--------
 src/diff.c              | 10 +++++-----
 src/endpoints.c         |  5 +++--
 src/extract_col.c       | 22 +++++++++++-----------
 src/isOrdered.c         |  4 ++--
 src/merge.c             | 31 ++++++++++++++++---------------
 src/na.c                | 18 +++++++++---------
 src/period_apply.c      |  4 ++--
 src/period_arithmetic.c | 12 ++++++------
 src/period_quantile.c   |  8 ++++----
 src/rbind.c             | 20 ++++++++++----------
 src/rollfun.c           | 30 +++++++++++++++++-------------
 src/runSum.c            |  8 ++++----
 src/subset.c            | 19 ++++++++++---------
 src/subset.old.c        | 22 +++++++++++-----------
 src/unique.time.c       | 10 +++++-----
 19 files changed, 138 insertions(+), 131 deletions(-)

diff --git a/inst/include/xts.h b/inst/include/xts.h
index 25dcf5f0..408c274b 100644
--- a/inst/include/xts.h
+++ b/inst/include/xts.h
@@ -111,7 +111,7 @@ void copy_xtsAttributes(SEXP x, SEXP y);    // internal only
 void copy_xtsCoreAttributes(SEXP x, SEXP y);// internal only    
 
 SEXP isXts(SEXP x);                         // is.xts analogue
-int firstNonNA(SEXP x);
+R_xlen_t firstNonNA(SEXP x);
 SEXP extract_col (SEXP x, SEXP j, SEXP drop, SEXP first_, SEXP last_);
 SEXP do_startofyear(SEXP from, SEXP to, SEXP origin);
 int xts_ncols(SEXP x);
diff --git a/src/any.c b/src/any.c
index 4f089186..0f01fe35 100644
--- a/src/any.c
+++ b/src/any.c
@@ -25,8 +25,8 @@
 
 SEXP any_negative (SEXP i_)
 {
-  int i;
-  int len = length(i_);
+  R_xlen_t i;
+  R_xlen_t len = xlength(i_);
 
   int *int_i=NULL;
   double *real_i=NULL;
diff --git a/src/binsearch.c b/src/binsearch.c
index 0880584a..9f59cd48 100644
--- a/src/binsearch.c
+++ b/src/binsearch.c
@@ -76,7 +76,7 @@ SEXP binsearch(SEXP key, SEXP vec, SEXP start)
     error("start must be specified as true or false");
   }
 
-  if (length(vec) < 1 || length(key) < 1) {
+  if (xlength(vec) < 1 || length(key) < 1) {
     return ScalarInteger(NA_INTEGER);
   }
 
@@ -105,9 +105,9 @@ SEXP binsearch(SEXP key, SEXP vec, SEXP start)
       error("unsupported type");
   }
 
-  int mid;
-  int lo = 0;
-  int hi = length(vec) - 1;
+  R_xlen_t mid;
+  R_xlen_t lo = 0;
+  R_xlen_t hi = xlength(vec) - 1;
 
   while (lo < hi) {
     mid = lo + (hi - lo) / 2;
@@ -126,7 +126,7 @@ SEXP binsearch(SEXP key, SEXP vec, SEXP start)
     /* cmp_func() := vector[index] >= key when start == true, and we need
      * to return the smallest index subject to vector[index] >= key.
      */
-    if (!cmp_func(data, length(vec)-1)) {
+    if (!cmp_func(data, xlength(vec)-1)) {
       /* entire vector < key */
       return ScalarInteger(NA_INTEGER);
     }
@@ -158,19 +158,19 @@ SEXP fill_window_dups_rev(SEXP _x, SEXP _index)
    * upper bound of the location of the user index in the xts index.
    * This is necessary to handle duplicate dates in the xts index.
    */
-  int n_x = length(_x);
+  R_xlen_t n_x = xlength(_x);
   int *x = INTEGER(_x);
 
-  if (length(_index) < 1) {
+  if (xlength(_index) < 1) {
     return allocVector(INTSXP, 0);
   }
 
   PROTECT_INDEX px;
   SEXP _out;
-  PROTECT_WITH_INDEX(_out = allocVector(INTSXP, length(_index)), &px);
+  PROTECT_WITH_INDEX(_out = allocVector(INTSXP, xlength(_index)), &px);
   int *out = INTEGER(_out);
 
-  int i, xi, j, k = 0, n_out = length(_out);
+  R_xlen_t i, xi, j, k = 0, n_out = xlength(_out);
   switch (TYPEOF(_index)) {
     case REALSXP:
       {
@@ -184,7 +184,7 @@ SEXP fill_window_dups_rev(SEXP _x, SEXP _index)
             if (k == n_out) {
               REPROTECT(_out = xlengthgets(_out, k+2*(i+1)), px);
               out = INTEGER(_out);
-              n_out = length(_out);
+              n_out = xlength(_out);
             }
             out[k++] = j--;
           } while (j > 0 && index[xi-1] == index[j-1]);
@@ -203,7 +203,7 @@ SEXP fill_window_dups_rev(SEXP _x, SEXP _index)
             if (k == n_out) {
               REPROTECT(_out = xlengthgets(_out, k+2*(i+1)), px);
               out = INTEGER(_out);
-              n_out = length(_out);
+              n_out = xlength(_out);
             }
             out[k++] = j--;
           } while (j > 0 && index[xi-1] == index[j-1]);
@@ -214,7 +214,7 @@ SEXP fill_window_dups_rev(SEXP _x, SEXP _index)
       error("unsupported index type");
   }
 
-  /* truncate so length(_out) = k
+  /* truncate so xlength(_out) = k
    * NB: output is in reverse order!
    */
   REPROTECT(_out = xlengthgets(_out, k), px);
diff --git a/src/coredata.c b/src/coredata.c
index 26ad6dac..af1a7178 100644
--- a/src/coredata.c
+++ b/src/coredata.c
@@ -33,21 +33,21 @@ SEXP coredata (SEXP x, SEXP copyAttr)
      removing
   */
   SEXP result;
-  int i, j, ncs, nrs;
-  int P=0;
-  PROTECT(result = allocVector(TYPEOF(x), length(x))); P++;
+  R_xlen_t i, j, ncs, nrs;
+  int P = 0;
+  PROTECT(result = allocVector(TYPEOF(x), xlength(x))); P++;
   switch( TYPEOF(x)) {
     case REALSXP:
-      memcpy(REAL(result), REAL(x), length(result) * sizeof(double));
+      memcpy(REAL(result), REAL(x), xlength(result) * sizeof(double));
       break;
     case INTSXP:
-      memcpy(INTEGER(result), INTEGER(x), length(result) * sizeof(int));
+      memcpy(INTEGER(result), INTEGER(x), xlength(result) * sizeof(int));
       break;
     case LGLSXP:
-      memcpy(LOGICAL(result), LOGICAL(x), length(result) * sizeof(int));
+      memcpy(LOGICAL(result), LOGICAL(x), xlength(result) * sizeof(int));
       break;
     case CPLXSXP:
-      memcpy(COMPLEX(result), COMPLEX(x), length(result) * sizeof(Rcomplex));
+      memcpy(COMPLEX(result), COMPLEX(x), xlength(result) * sizeof(Rcomplex));
       break;
     case STRSXP:
       ncs = ncols(x); nrs = nrows(x);
@@ -56,7 +56,7 @@ SEXP coredata (SEXP x, SEXP copyAttr)
         SET_STRING_ELT(result, i+j*nrs, STRING_ELT(x, i+j*nrs));
       break;
     case RAWSXP:
-      memcpy(RAW(result), RAW(x), length(result) * sizeof(unsigned char));
+      memcpy(RAW(result), RAW(x), xlength(result) * sizeof(unsigned char));
       break;
     default:
       error("currently unsupported data type");
diff --git a/src/diff.c b/src/diff.c
index a108a22b..0fe9c858 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -34,9 +34,9 @@ SEXP diffXts(SEXP x, SEXP lag, SEXP diff, SEXP arith, SEXP nap, SEXP dots)
 SEXP lagXts(SEXP x, SEXP k, SEXP pad)
 {
   SEXP result;
-  int nrs, ncs;
-  int i, j, ij, iijj, K, NApad;
-  int mode;
+  R_xlen_t nrs, ncs;
+  R_xlen_t i, j, ij, iijj, K;
+  int mode, NApad;
   int P=0; /*PROTECT counter*/
   int *int_result=NULL, *int_x=NULL;
   int *lgl_result=NULL, *lgl_x=NULL;
@@ -169,8 +169,8 @@ SEXP lagXts(SEXP x, SEXP k, SEXP pad)
   setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
   if(!NApad) { /* No NA padding */
     SEXP oindex, nindex, dims;
-    int nRows = (K > 0) ? nrs-K : nrs+K;
-    int incr  = (K > 0) ? K : 0;
+    R_xlen_t nRows = (K > 0) ? nrs-K : nrs+K;
+    R_xlen_t incr  = (K > 0) ? K : 0;
     PROTECT(oindex = getAttrib(x, xts_IndexSymbol));
     PROTECT(nindex = allocVector(TYPEOF(oindex), nRows));
     switch(TYPEOF(oindex)) {
diff --git a/src/endpoints.c b/src/endpoints.c
index 02e45401..b687f1c8 100644
--- a/src/endpoints.c
+++ b/src/endpoints.c
@@ -32,9 +32,10 @@ SEXP endpoints (SEXP _x, SEXP _on, SEXP _k, SEXP _addlast /* TRUE */)
 
         c(0,which(diff(_x%/%on%/%k+1) != 0),NROW(_x))
   */
+  int P = 0;
   int *int_index = NULL;
   double *real_index = NULL;
-  int i=1,j=1, nr, P=0;
+  R_xlen_t i = 1, j = 1, nr;
   int int_tmp[2];
   int64_t int64_tmp[2];
 
@@ -134,7 +135,7 @@ SEXP endpoints (SEXP _x, SEXP _on, SEXP _k, SEXP _addlast /* TRUE */)
     ep[j] = nr;
     j++;
   }
-  PROTECT(_ep = lengthgets(_ep, j)); P++;
+  PROTECT(_ep = xlengthgets(_ep, j)); P++;
   UNPROTECT(P);
   return(_ep);
 }
diff --git a/src/extract_col.c b/src/extract_col.c
index ce622cc6..d4a02f28 100644
--- a/src/extract_col.c
+++ b/src/extract_col.c
@@ -39,7 +39,7 @@
 
 SEXP extract_col (SEXP x, SEXP j, SEXP drop, SEXP first_, SEXP last_) {
   SEXP result, index, new_index;
-  int nrs, nrsx, i, ii, jj, first, last;
+  R_xlen_t nrs, nrsx, i, ii, jj, first, last;
 
   nrsx = nrows(x);
 
@@ -50,11 +50,11 @@ SEXP extract_col (SEXP x, SEXP j, SEXP drop, SEXP first_, SEXP last_) {
   nrs = last - first + 1;
   
 
-  PROTECT(result = allocVector(TYPEOF(x), nrs * length(j)));
+  PROTECT(result = allocVector(TYPEOF(x), nrs * xlength(j)));
 
   switch(TYPEOF(x)) {
     case REALSXP:
-      for(i=0; i<length(j); i++) {
+      for(i=0; i<xlength(j); i++) {
 /*
 Rprintf("j + i*nrs + first=%i\n", (int)(INTEGER(j)[i]-1 + i*nrs + first));
 Rprintf("i=%i, j=%i, nrs=%i, first=%i\n", i, INTEGER(j)[i]-1, nrs, first);
@@ -71,7 +71,7 @@ Rprintf("i=%i, j=%i, nrs=%i, first=%i\n", i, INTEGER(j)[i]-1, nrs, first);
       }
       break;
     case INTSXP:
-      for(i=0; i<length(j); i++) {
+      for(i=0; i<xlength(j); i++) {
         if(INTEGER(j)[i] == NA_INTEGER) {
           for(ii=0; ii < nrs; ii++) {
             INTEGER(result)[(i*nrs) + ii] = NA_INTEGER;
@@ -84,7 +84,7 @@ Rprintf("i=%i, j=%i, nrs=%i, first=%i\n", i, INTEGER(j)[i]-1, nrs, first);
       }
       break;
     case LGLSXP:
-      for(i=0; i<length(j); i++) {
+      for(i=0; i<xlength(j); i++) {
         if(INTEGER(j)[i] == NA_INTEGER) {
           for(ii=0; ii < nrs; ii++) {
             LOGICAL(result)[(i*nrs) + ii] = NA_LOGICAL;
@@ -97,7 +97,7 @@ Rprintf("i=%i, j=%i, nrs=%i, first=%i\n", i, INTEGER(j)[i]-1, nrs, first);
       }
       break;
     case CPLXSXP:
-      for(i=0; i<length(j); i++) {
+      for(i=0; i<xlength(j); i++) {
         if(INTEGER(j)[i] == NA_INTEGER) {
           for(ii=0; ii < nrs; ii++) {
             COMPLEX(result)[(i*nrs) + ii].r = NA_REAL;
@@ -111,7 +111,7 @@ Rprintf("i=%i, j=%i, nrs=%i, first=%i\n", i, INTEGER(j)[i]-1, nrs, first);
       }
       break;
     case RAWSXP:
-      for(i=0; i<length(j); i++) {
+      for(i=0; i<xlength(j); i++) {
         if(INTEGER(j)[i] == NA_INTEGER) {
           for(ii=0; ii < nrs; ii++) {
             RAW(result)[(i*nrs) + ii] = 0;
@@ -124,7 +124,7 @@ Rprintf("i=%i, j=%i, nrs=%i, first=%i\n", i, INTEGER(j)[i]-1, nrs, first);
       }
       break;
     case STRSXP:
-      for(jj=0; jj<length(j); jj++) {
+      for(jj=0; jj<xlength(j); jj++) {
         if(INTEGER(j)[jj] == NA_INTEGER) {
           for(i=0; i< nrs; i++)
             SET_STRING_ELT(result, i+jj*nrs, NA_STRING);
@@ -159,20 +159,20 @@ Rprintf("i=%i, j=%i, nrs=%i, first=%i\n", i, INTEGER(j)[i]-1, nrs, first);
     SEXP dim;
     PROTECT(dim = allocVector(INTSXP, 2));
     INTEGER(dim)[0] = nrs;
-    INTEGER(dim)[1] = length(j);
+    INTEGER(dim)[1] = xlength(j);
     setAttrib(result, R_DimSymbol, dim);
     UNPROTECT(1);
 
     SEXP dimnames, currentnames, newnames;
     PROTECT(dimnames = allocVector(VECSXP, 2));
-    PROTECT(newnames = allocVector(STRSXP, length(j)));
+    PROTECT(newnames = allocVector(STRSXP, xlength(j)));
     currentnames = getAttrib(x, R_DimNamesSymbol);
 
     if(!isNull(currentnames)) {
       SET_VECTOR_ELT(dimnames, 0, VECTOR_ELT(currentnames,0));
       if(!isNull(VECTOR_ELT(currentnames,1))) {
         /* if colnames isn't NULL set */
-        for(i=0; i<length(j); i++) {
+        for(i=0; i<xlength(j); i++) {
           if(INTEGER(j)[i] == NA_INTEGER) {
             SET_STRING_ELT(newnames, i, NA_STRING);
           } else {
diff --git a/src/isOrdered.c b/src/isOrdered.c
index 3e07a603..1d4fe70f 100644
--- a/src/isOrdered.c
+++ b/src/isOrdered.c
@@ -26,8 +26,8 @@
 
 SEXP do_is_ordered (SEXP x, SEXP increasing, SEXP strictly)
 {
-  int i;
-  int nx = LENGTH(x) - 1;
+  R_xlen_t i;
+  R_xlen_t nx = xlength(x) - 1;
   double *real_x;
   int *int_x;
 
diff --git a/src/merge.c b/src/merge.c
index a7dcf163..ae02b547 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -172,7 +172,7 @@ SEXP do_merge_xts (SEXP x, SEXP y,
     SETCAR(t, install("try.xts")); t = CDR(t);
     SETCAR(t, y); t = CDR(t);
     PROTECT( len_xindex = allocVector(INTSXP, 1)); p++;
-    INTEGER(len_xindex)[0] = length(xindex);
+    INTEGER(len_xindex)[0] = xlength(xindex);
     SETCAR(t, len_xindex);
     SET_TAG(t, install("length.out")); t = CDR(t);
     SETCAR(t, install(".merge.xts.scalar"));
@@ -193,7 +193,7 @@ SEXP do_merge_xts (SEXP x, SEXP y,
 
   /* determine number of rows and columns to use for the inputs */
   int return_x_data = LOGICAL(retside)[0];
-  int is_xobs_zero = LENGTH(x) == 0;
+  int is_xobs_zero = xlength(x) == 0;
   int is_xdim_null = isNull(getAttrib(x, R_DimSymbol));
 
   nrx = nrows(x);
@@ -202,25 +202,25 @@ SEXP do_merge_xts (SEXP x, SEXP y,
   if (return_x_data) {
     if (is_xdim_null) {
       if (is_xobs_zero) {
-        nrx = LENGTH(xindex);
+        nrx = xlength(xindex);
         ncx = 0;
         PROTECT(x = coerceVector(x, TYPEOF(y))); p++;
       }
     } else {
       if (is_xobs_zero) {
-        nrx = LENGTH(xindex);
+        nrx = xlength(xindex);
         ncx = INTEGER(getAttrib(x, R_DimSymbol))[1];
         PROTECT(x = coerceVector(x, TYPEOF(y))); p++;
       }
     }
   } else {
-    nrx = LENGTH(xindex);
+    nrx = xlength(xindex);
     ncx = 0;
     PROTECT(x = coerceVector(x, TYPEOF(y))); p++;
   }
 
   int return_y_data = LOGICAL(retside)[1];
-  int is_yobs_zero = LENGTH(y) == 0;
+  int is_yobs_zero = xlength(y) == 0;
   int is_ydim_null = isNull(getAttrib(y, R_DimSymbol));
 
   nry = nrows(y);
@@ -229,19 +229,19 @@ SEXP do_merge_xts (SEXP x, SEXP y,
   if (return_y_data) {
     if (is_ydim_null) {
       if (is_yobs_zero) {
-        nry = LENGTH(yindex);
+        nry = xlength(yindex);
         ncy = 0;
         PROTECT(y = coerceVector(y, TYPEOF(x))); p++;
       }
     } else {
       if (is_yobs_zero) {
-        nry = LENGTH(yindex);
+        nry = xlength(yindex);
         ncy = INTEGER(getAttrib(y, R_DimSymbol))[1];
         PROTECT(y = coerceVector(y, TYPEOF(x))); p++;
       }
     }
   } else {
-    nry = LENGTH(yindex);
+    nry = xlength(yindex);
     ncy = 0;
     PROTECT(y = coerceVector(y, TYPEOF(x))); p++;
   }
@@ -409,7 +409,7 @@ SEXP do_merge_xts (SEXP x, SEXP y,
   PROTECT( result = allocVector(TYPEOF(x), (ncx + ncy) * num_rows) ); p++;
 
   /* Ensure fill is the correct length and type */
-  if( length(fill) < 1 ) {
+  if( xlength(fill) < 1 ) {
     PROTECT( fill = ScalarLogical(NA_LOGICAL) ); p++;
   }
   if( TYPEOF(fill) != TYPEOF(x) ) {
@@ -1128,8 +1128,8 @@ SEXP mergeXts (SEXP args) // mergeXts {{{
   /* colnames should be renamed as suffixes, as colnames need to be added at the C level */
   SEXP all, fill, retc, retclass, symnames,
        suffixes, rets, retside, env, tzone, check_names;
-  int nr, nc, ncs=0;
-  int index_len;
+  R_xlen_t nr, nc, ncs=0;
+  R_xlen_t index_len;
   int i, n=0, P=0;
 
   SEXP argstart;
@@ -1244,11 +1244,9 @@ SEXP mergeXts (SEXP args) // mergeXts {{{
       args = CDR(args);
     }
 
-    index_len = length(GET_xtsIndex(_INDEX));
-  
     args = argstart; // reset args
-    int ii, jj, iijj, jj_result;
 
+    index_len = xlength(GET_xtsIndex(_INDEX));
     PROTECT(result = allocVector(TYPEOF(_INDEX), index_len * ncs)); P++;
 
     SEXP ColNames, NewColNames;
@@ -1290,6 +1288,7 @@ SEXP mergeXts (SEXP args) // mergeXts {{{
       if(R_NilValue != ColNames) {
         colnames = VECTOR_ELT(ColNames, 1);
       }
+      R_xlen_t jj;
       if(R_NilValue == colnames) {
         for(jj=0; jj < nc; jj++) {
           SET_STRING_ELT(NewColNames, i+jj, STRING_ELT(symnames,i+jj));
@@ -1300,6 +1299,8 @@ SEXP mergeXts (SEXP args) // mergeXts {{{
         }
       }
 
+      R_xlen_t ii, iijj, jj_result;
+
       switch(TYPEOF(xtmp)) { // by type, insert merged data into result object
         case LGLSXP:
           {
diff --git a/src/na.c b/src/na.c
index 68af0424..dd23857f 100644
--- a/src/na.c
+++ b/src/na.c
@@ -27,9 +27,9 @@
 /* Internal use only
  * called by: firstNonNA, naCheck, na_locf
  */
-static int firstNonNACol (SEXP x, int col)
+static R_xlen_t firstNonNACol (SEXP x, R_xlen_t col)
 {
-  int i=0, nr;
+  R_xlen_t i=0, nr;
   int *int_x=NULL;
   double *real_x=NULL;
 
@@ -78,7 +78,7 @@ static int firstNonNACol (SEXP x, int col)
 
 /* Should be internal use only (static), but is in xts.h
  */
-int firstNonNA (SEXP x)
+R_xlen_t firstNonNA (SEXP x)
 {
   return firstNonNACol(x, 0);
 }
@@ -89,15 +89,14 @@ SEXP naCheck (SEXP x, SEXP check)
     Check for non-leading NA values, throw error if found
   */
   SEXP first;
-  int _first;
-  _first = firstNonNA(x);
+  R_xlen_t _first = firstNonNA(x);
   PROTECT(first = allocVector(INTSXP, 1));
   INTEGER(first)[0] = _first;
 
 
   if(LOGICAL(check)[0]) {
   /* check for NAs in rest of data */
-  int i, nr;
+  R_xlen_t i, nr;
   int *int_x = NULL;
   double *real_x = NULL;
 
@@ -146,7 +145,8 @@ SEXP na_locf (SEXP x, SEXP fromLast, SEXP _maxgap, SEXP _limit)
 {
   SEXP result;
 
-  int i, ii, j, nr, nc, _first=0, P=0;
+  int P = 0;
+  R_xlen_t i, ii, j, nr, nc, _first=0;
   double gap, maxgap, limit;
 
   int *int_x=NULL, *int_result=NULL;
@@ -407,8 +407,8 @@ SEXP na_omit_xts (SEXP x)
 {
   SEXP na_index, not_na_index, col_index, result;
 
-  int i, j, ij, nr, nc; 
-  int not_NA, NA;
+  R_xlen_t i, j, ij, nr, nc;
+  R_xlen_t not_NA, NA;
 
   nr = nrows(x);
   nc = ncols(x);
diff --git a/src/period_apply.c b/src/period_apply.c
index 8345a0ad..c8475752 100644
--- a/src/period_apply.c
+++ b/src/period_apply.c
@@ -24,7 +24,7 @@
 
 SEXP xts_period_apply(SEXP _data, SEXP _index, SEXP _function, SEXP _env)
 {
-  int i;
+  R_xlen_t i;
   R_xlen_t n = xlength(_index);
   SEXP _result = PROTECT(allocVector(VECSXP, n));
   SEXP _j = PROTECT(allocVector(INTSXP, ncols(_data)));
@@ -50,7 +50,7 @@ SEXP xts_period_apply(SEXP _data, SEXP _index, SEXP _function, SEXP _env)
   /* function call on subset */
   SEXP _subcall = PROTECT(lang3(_function, _subsym, R_DotsSymbol));
 
-  int N = n - 1;
+  R_xlen_t N = n - 1;
 
   switch(TYPEOF(_index)) {
     case REALSXP:
diff --git a/src/period_arithmetic.c b/src/period_arithmetic.c
index d590d8b1..89e9da1b 100644
--- a/src/period_arithmetic.c
+++ b/src/period_arithmetic.c
@@ -33,14 +33,14 @@ SEXP xts_period_prod(SEXP _data, SEXP _index)
     error("data must be double");
   }
 
-  int i, j;
-  int n = length(_index) - 1;
+  R_xlen_t i, j;
+  R_xlen_t n = xlength(_index) - 1;
   SEXP _result = PROTECT(allocVector(REALSXP, n));
   double *result = REAL(_result);
 
   int *index = INTEGER(_index);
   double *data = REAL(_data);
-  int k = 0;
+  R_xlen_t k = 0;
 
   for (i = 0; i < n; i++) {
     int idx0 = index[i];
@@ -68,14 +68,14 @@ SEXP xts_period_sum(SEXP _data, SEXP _index)
     error("data must be double");
   }
 
-  int i, j;
-  int n = length(_index) - 1;
+  R_xlen_t i, j;
+  R_xlen_t n = xlength(_index) - 1;
   SEXP _result = PROTECT(allocVector(REALSXP, n));
   double *result = REAL(_result);
 
   int *index = INTEGER(_index);
   double *data = REAL(_data);
-  int k = 0;
+  R_xlen_t k = 0;
 
   for (i = 0; i < n; i++) {
     int idx0 = index[i];
diff --git a/src/period_quantile.c b/src/period_quantile.c
index ca543b95..6eb402ad 100644
--- a/src/period_quantile.c
+++ b/src/period_quantile.c
@@ -33,8 +33,8 @@ SEXP xts_period_max(SEXP _data, SEXP _index)
     error("data must be double");
   }
 
-  int i, j;
-  int n = length(_index) - 1;
+  R_xlen_t i, j;
+  R_xlen_t n = xlength(_index) - 1;
   SEXP _result = PROTECT(allocVector(REALSXP, n));
   double *result = REAL(_result);
 
@@ -70,8 +70,8 @@ SEXP xts_period_min(SEXP _data, SEXP _index)
     error("data must be double");
   }
 
-  int i, j;
-  int n = length(_index) - 1;
+  R_xlen_t i, j;
+  R_xlen_t n = xlength(_index) - 1;
   SEXP _result = PROTECT(allocVector(REALSXP, n));
   double *result = REAL(_result);
 
diff --git a/src/rbind.c b/src/rbind.c
index 328048ad..5b703e03 100644
--- a/src/rbind.c
+++ b/src/rbind.c
@@ -30,9 +30,9 @@ SEXP rbind_append(SEXP, SEXP);
 //SEXP do_rbind_xts (SEXP x, SEXP y, SEXP env) {{{
 SEXP do_rbind_xts (SEXP x, SEXP y, SEXP dup)
 {
-  int nrx, ncx, nry, ncy, truelen, len;
+  R_xlen_t nrx, ncx, nry, ncy, truelen, len;
   int no_duplicate = LOGICAL(dup)[0];
-  int i, j, ij, ij_x, ij_y, xp=1, yp=1, add_y=0;
+  R_xlen_t i, j, ij, ij_x, ij_y, xp=1, yp=1, add_y=0;
   int P=0; // PROTECT counter
   int mode;
   SEXP result, xindex, yindex, newindex;
@@ -89,20 +89,20 @@ SEXP do_rbind_xts (SEXP x, SEXP y, SEXP dup)
 
 #ifdef RBIND_APPEND
 if(TYPEOF(xindex)==REALSXP) {
-  if(REAL(xindex)[length(xindex)-1] < REAL(yindex)[0]) {
+  if(REAL(xindex)[xlength(xindex)-1] < REAL(yindex)[0]) {
     UNPROTECT(P);
     return rbind_append(x,y);
     }
 } else
 if(TYPEOF(xindex)==INTSXP) {
-  if(INTEGER(xindex)[length(xindex)-1] < INTEGER(yindex)[0]) {
+  if(INTEGER(xindex)[xlength(xindex)-1] < INTEGER(yindex)[0]) {
     UNPROTECT(P);
     return rbind_append(x,y);
     }
 }
 #endif
 
-  if(nrx != length(xindex) || nry != length(yindex))
+  if(nrx != xlength(xindex) || nry != xlength(yindex))
     error("zero-length vectors with non-zero-length index are not allowed");
 
   PROTECT(newindex = allocVector(TYPEOF(xindex), len)); P++;
@@ -482,7 +482,7 @@ return(result);
   }
 
   if(truelen != len) {
-    PROTECT(result = lengthgets(result, truelen * ncx)); P++;  /* reset length */
+    PROTECT(result = xlengthgets(result, truelen * ncx)); P++;  /* reset length */
   }
   setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
   SEXP dim;
@@ -494,7 +494,7 @@ return(result);
   setAttrib(result, R_DimNamesSymbol, getAttrib(x, R_DimNamesSymbol));
   
   if(truelen != len) {
-    PROTECT(newindex = lengthgets(newindex, truelen)); P++;
+    PROTECT(newindex = xlengthgets(newindex, truelen)); P++;
   }
   copyMostAttrib(xindex, newindex);
 
@@ -551,8 +551,8 @@ SEXP rbind_append (SEXP x, SEXP y) {
 */
   /*Rprintf("rbind_append called\n");*/
   SEXP result;
-  int nrs_x, nrs_y, ncs_x, ncs_y, nr;
-  int i;
+  R_xlen_t nrs_x, nrs_y, ncs_x, ncs_y, nr;
+  R_xlen_t i;
 
   ncs_x = ncols(x); ncs_y = ncols(y); nrs_x = nrows(x); nrs_y = nrows(y);
 
@@ -654,7 +654,7 @@ SEXP rbind_append (SEXP x, SEXP y) {
 /*
     SEXP dimnames, currentnames, newnames;
     PROTECT(dimnames = allocVector(VECSXP, 2));
-    PROTECT(newnames = allocVector(STRSXP, length(j)));
+    PROTECT(newnames = allocVector(STRSXP, xlength(j)));
     currentnames = getAttrib(x, R_DimNamesSymbol);
 
     if(!isNull(currentnames)) {
diff --git a/src/rollfun.c b/src/rollfun.c
index a61abba8..eec7734a 100644
--- a/src/rollfun.c
+++ b/src/rollfun.c
@@ -37,7 +37,8 @@ void kahan_sum(long double x, long double * c, long double * sum)
 SEXP roll_sum (SEXP x, SEXP n)
 {
   /* Author: Joshua Ulrich, with contributions from Ivan Popivanov */
-  int i, P=0, nrs;
+  int P = 0;
+  R_xlen_t i, nrs;
   nrs = nrows(x);
 
   /* Get values from pointers */
@@ -45,7 +46,7 @@ SEXP roll_sum (SEXP x, SEXP n)
 
   /* Initalize result R object */
   SEXP result;
-  PROTECT(result = allocVector(TYPEOF(x), length(x))); P++;
+  PROTECT(result = allocVector(TYPEOF(x), xlength(x))); P++;
   int *int_result=NULL, *int_x=NULL;
   int int_sum = 0;
   double *real_result=NULL, *real_x=NULL;
@@ -115,7 +116,8 @@ SEXP roll_sum (SEXP x, SEXP n)
 SEXP roll_min (SEXP x, SEXP n)
 {
   /* Author: Joshua Ulrich */
-  int i, j, P=0;
+  int P = 0;
+  R_xlen_t i, j;
 
   /* Get values from pointers */
   int int_n = asInteger(n);
@@ -125,12 +127,12 @@ SEXP roll_min (SEXP x, SEXP n)
   int int_min;
   double *real_result=NULL, *real_x=NULL;
   double real_min;
-  int nrs = nrows(x);
-  int loc;
+  R_xlen_t nrs = nrows(x);
+  R_xlen_t loc;
 
   /* Initalize result R object */
   SEXP result;
-  PROTECT(result = allocVector(TYPEOF(x), length(x))); P++;
+  PROTECT(result = allocVector(TYPEOF(x), xlength(x))); P++;
 
   /* check for non-leading NAs and get first non-NA location */
   SEXP first;
@@ -245,7 +247,8 @@ SEXP roll_min (SEXP x, SEXP n)
 SEXP roll_max (SEXP x, SEXP n)
 {
   /* Author: Joshua Ulrich */
-  int i, j, P=0;
+  int P = 0;
+  R_xlen_t i, j;
 
   /* Get values from pointers */
   int int_n = asInteger(n);
@@ -255,12 +258,12 @@ SEXP roll_max (SEXP x, SEXP n)
   int int_min;
   double *real_result=NULL, *real_x=NULL;
   double real_max;
-  int nrs = nrows(x);
-  int loc;
+  R_xlen_t nrs = nrows(x);
+  R_xlen_t loc;
 
   /* Initalize result R object */
   SEXP result;
-  PROTECT(result = allocVector(TYPEOF(x), length(x))); P++;
+  PROTECT(result = allocVector(TYPEOF(x), xlength(x))); P++;
 
   /* check for non-leading NAs and get first non-NA location */
   SEXP first;
@@ -375,12 +378,13 @@ SEXP roll_max (SEXP x, SEXP n)
 SEXP roll_cov (SEXP x, SEXP y, SEXP n, SEXP samp)
 {
   /* Author: Joshua Ulrich */
-  int i, P=0;
+  int P = 0;
+  R_xlen_t i;
 
   /* ensure x and y have same length in R functions, since it's 
    * easier to throw user-informative errors */
-  int nrx = nrows(x);
-  int nry = nrows(y);
+  R_xlen_t nrx = nrows(x);
+  R_xlen_t nry = nrows(y);
   if(nrx != nry) error("nrx != nry, blame the R function writer");
 
   /* Coerce to REALSXP to ensure roll_sum returns REALSXP */
diff --git a/src/runSum.c b/src/runSum.c
index f6af7b48..8a22ec35 100644
--- a/src/runSum.c
+++ b/src/runSum.c
@@ -57,7 +57,7 @@ SEXP do_run (SEXP x, SEXP n, (*void)FUN)
   double *real_result=NULL, *real_x=NULL;
   double real_sum = 0.0;
 
-  PROTECT(result = allocVector(TYPEOF(x), length(x))); P++;
+  PROTECT(result = allocVector(TYPEOF(x), xlength(x))); P++;
 
   int _firstNonNA = firstNonNA(x);
 
@@ -68,7 +68,7 @@ SEXP runSum (SEXP x, SEXP n)
 {
   SEXP result;
   int P=0;
-  int i, nrs;
+  R_xlen_t i, nrs;
   int *int_n=NULL;
   if(TYPEOF(n) != INTSXP) {
     // assure that 'n' is an integer
@@ -81,9 +81,9 @@ SEXP runSum (SEXP x, SEXP n)
   double *real_result=NULL, *real_x=NULL;
   double real_sum = 0.0;
 
-  PROTECT(result = allocVector(TYPEOF(x), length(x))); P++;
+  PROTECT(result = allocVector(TYPEOF(x), xlength(x))); P++;
 
-  int _firstNonNA = firstNonNA(x);
+  R_xlen_t _firstNonNA = firstNonNA(x);
 
   
   switch(TYPEOF(x)) {
diff --git a/src/subset.c b/src/subset.c
index b2d6dfe4..319c329e 100644
--- a/src/subset.c
+++ b/src/subset.c
@@ -31,19 +31,19 @@ static SEXP xts_ExtractSubset(SEXP x, SEXP result, SEXP indx) //, SEXP call)
        This is slated to be reimplemented using the previous method
        in xts to get the correct dimnames
     */
-    int i, ii, n, nx, mode;
     SEXP tmp, tmp2;
-    mode = TYPEOF(x);
-    n = LENGTH(indx); 
-    nx = length(x);
+    int mode = TYPEOF(x);
+    R_xlen_t n = xlength(indx);
+    R_xlen_t nx = xlength(x);
     tmp = result;
     
     /*if (x == R_NilValue)*/
     if (isNull(x))
     return x;
     
+    R_xlen_t i;
     for (i = 0; i < n; i++) {
-    ii = INTEGER(indx)[i];
+    int ii = INTEGER(indx)[i];
     if (ii != NA_INTEGER)
         ii--;
     switch (mode) {
@@ -115,18 +115,19 @@ static SEXP xts_ExtractSubset(SEXP x, SEXP result, SEXP indx) //, SEXP call)
 
 SEXP _do_subset_xts (SEXP x, SEXP sr, SEXP sc, SEXP drop) {
   SEXP result;
-  int i, j, nr, nc, nrs, ncs;
   int P=0;
 
   SEXP Dim = getAttrib(x, R_DimSymbol);
-  nrs = nrows(x);ncs = ncols(x);
-  nr = length(sr); nc = length(sc);
+  R_xlen_t nrs = nrows(x);
+  R_xlen_t ncs = ncols(x);
+  R_xlen_t nr = xlength(sr);
+  R_xlen_t nc = xlength(sc);
 
   SEXP oindex, nindex;
   oindex = getAttrib(x, xts_IndexSymbol);
   PROTECT(nindex = allocVector(TYPEOF(oindex), nr)); P++;
   PROTECT(result = allocVector(TYPEOF(x), nr*nc)); P++;
-  j = 0;
+  R_xlen_t i, j = 0;
 
   double *real_nindex=NULL, *real_oindex, *real_result=NULL, *real_x=NULL; 
   int *int_nindex=NULL, *int_oindex, *int_result=NULL, *int_x=NULL; 
diff --git a/src/subset.old.c b/src/subset.old.c
index 6f092cfd..76292b44 100644
--- a/src/subset.old.c
+++ b/src/subset.old.c
@@ -34,11 +34,11 @@ All modification are by Jeffrey A. Ryan 2008
 // xtsExtractSubset {{{
 static SEXP xtsExtractSubset(SEXP x, SEXP result, SEXP indx) //, SEXP call)
 {
-    int i, ii, n, nx, mode;
+    R_xlen_t i, ii;
     SEXP tmp, tmp2;
-    mode = TYPEOF(x);
-    n = LENGTH(indx);
-    nx = length(x);
+    int mode = TYPEOF(x);
+    R_xlen_t n = xlength(indx);
+    R_xlen_t nx = xlength(x);
     tmp = result;
 
     if (x == R_NilValue)
@@ -119,8 +119,8 @@ static SEXP xtsExtractSubset(SEXP x, SEXP result, SEXP indx) //, SEXP call)
 SEXP do_subset_xts(SEXP x, SEXP sr, SEXP sc, SEXP drop) //SEXP s, SEXP call, int drop)
 {
     SEXP attr, result, dim;
-    int nr, nc, nrs, ncs;
-    int i, j, ii, jj, ij, iijj;
+    R_xlen_t nr, nc, nrs, ncs;
+    R_xlen_t i, j, ii, jj, ij, iijj;
     int mode;
     int *int_x=NULL, *int_result=NULL, *int_newindex=NULL, *int_index=NULL;
     double *real_x=NULL, *real_result=NULL, *real_newindex=NULL, *real_index=NULL;
@@ -128,13 +128,13 @@ SEXP do_subset_xts(SEXP x, SEXP sr, SEXP sc, SEXP drop) //SEXP s, SEXP call, int
     nr = nrows(x);
     nc = ncols(x);
 
-    if( length(x)==0 )
+    if( xlength(x)==0 )
       return x;
 
     dim = getAttrib(x, R_DimSymbol);
 
-    nrs = LENGTH(sr);
-    ncs = LENGTH(sc);
+    nrs = xlength(sr);
+    ncs = xlength(sc);
     int *int_sr=NULL, *int_sc=NULL;
     int_sr = INTEGER(sr);
     int_sc = INTEGER(sc);
@@ -162,7 +162,7 @@ SEXP do_subset_xts(SEXP x, SEXP sr, SEXP sc, SEXP drop) //SEXP s, SEXP call, int
     PROTECT(index);
 
     if(TYPEOF(index) == INTSXP) {
-      newindex = allocVector(INTSXP, LENGTH(sr));
+      newindex = allocVector(INTSXP, xlength(sr));
       PROTECT(newindex);
       int_newindex = INTEGER(newindex);
       int_index = INTEGER(index);
@@ -174,7 +174,7 @@ SEXP do_subset_xts(SEXP x, SEXP sr, SEXP sc, SEXP drop) //SEXP s, SEXP call, int
       UNPROTECT(1);
     }
     if(TYPEOF(index) == REALSXP) {
-      newindex = allocVector(REALSXP, LENGTH(sr));
+      newindex = allocVector(REALSXP, xlength(sr));
       PROTECT(newindex);
       real_newindex = REAL(newindex);
       real_index = REAL(index);
diff --git a/src/unique.time.c b/src/unique.time.c
index ec31006f..abe4f824 100644
--- a/src/unique.time.c
+++ b/src/unique.time.c
@@ -24,8 +24,8 @@
 #include "xts.h" /* for coredata_xts */
 
 SEXP make_unique (SEXP index_, SEXP eps_) {
-  int P = 0, i;
-  int len = length(index_);
+  int P = 0;
+  R_xlen_t i, len = xlength(index_);
   double eps = asReal(eps_);
 
   if (TYPEOF(index_) == INTSXP) {
@@ -63,9 +63,9 @@ SEXP make_index_unique (SEXP x_, SEXP eps_) {
 }
 
 SEXP non_duplicates (SEXP x_, SEXP fromLast_) {
-  int fromLast = asLogical(fromLast_),
-      i, d=0,
-      len   = length(x_);
+  int fromLast = asLogical(fromLast_);
+  R_xlen_t len = xlength(x_);
+  R_xlen_t i, d = 0;
   
   int *x_int;
   double *x_real;