SEXP mc_children()
{
rm_closed();
child_info_t *ci = children;
unsigned int count = 0;
while (ci && ci->pid > 0) {
count++;
ci = ci->next;
}
SEXP res = allocVector(INTSXP, count);
if (count) {
int *pids = INTEGER(res);
ci = children;
while (ci && ci->pid > 0) {
(pids++)[0] = ci->pid;
ci = ci->next;
}
/* in theory signals can flag a pid as closed in the
meantime, we may end up with fewer children than
expected - highly unlikely but possible */
if (pids - INTEGER(res) < LENGTH(res)) {
R_len_t len = (R_len_t) (pids - INTEGER(res));
PROTECT(res);
res = lengthgets(res, len);
UNPROTECT(1);
}
}
return res;
}
/*
#define xts_IndexSymbol install("index")
#define xts_ClassSymbol install(".CLASS")
#define xts_IndexFormatSymbol install(".indexFORMAT")
#define xts_IndexClassSymbol install(".indexCLASS")
#define xts_ATTRIB(x) coerceVector(do_xtsAttributes(x),LISTSXP)
*/
SEXP do_xtsAttributes(SEXP x)
{
SEXP a, values, names;
int i=0, P=0;
a = ATTRIB(x);
if(length(a) <= 0)
return R_NilValue;
PROTECT(a); P++; /* all attributes */
PROTECT(values = allocVector(VECSXP, length(a))); P++;
PROTECT(names = allocVector(STRSXP, length(a))); P++;
/*
CAR gets the first element of the dotted pair list
CDR gets the rest of the dotted pair list
TAG gets the symbol/name of the first element of dotted pair list
*/
for( /* a=ATTRIB(a) */; a != R_NilValue; a = CDR(a) ) {
if(TAG(a) != xts_IndexSymbol &&
TAG(a) != xts_ClassSymbol &&
TAG(a) != xts_IndexFormatSymbol &&
TAG(a) != xts_IndexClassSymbol &&
TAG(a) != xts_IndexTZSymbol &&
TAG(a) != R_ClassSymbol &&
TAG(a) != R_DimSymbol &&
TAG(a) != R_DimNamesSymbol &&
TAG(a) != R_NamesSymbol)
{
SET_VECTOR_ELT(values, i, CAR(a));
SET_STRING_ELT(names, i, PRINTNAME(TAG(a)));
i++;
}
}
if(i == 0) {
UNPROTECT(P);
return R_NilValue;
}
/* truncate list back to i-size */
PROTECT(values = lengthgets(values, i)); P++;
PROTECT(names = lengthgets(names, i)); P++;
setAttrib(values, R_NamesSymbol, names);
UNPROTECT(P);
return values;
}
SEXP ar2ma(SEXP ar, SEXP npsi)
{
ar = PROTECT(coerceVector(ar, REALSXP));
int p = LENGTH(ar), ns = asInteger(npsi), ns1 = ns + p + 1;
SEXP psi = PROTECT(allocVector(REALSXP, ns1));
artoma(p, REAL(ar), REAL(psi), ns1);
SEXP ans = lengthgets(psi, ns);
UNPROTECT(2);
return ans;
}
static BOOL CALLBACK EnumWindowsProc(HWND handle, LPARAM param)
{
char title[1024];
if (IsWindowVisible(handle)) {
if (EnumProcessId) { /* restrict to R windows only */
DWORD processId;
GetWindowThreadProcessId(handle, &processId);
if (processId != EnumProcessId) return TRUE;
}
if (!EnumMinimized && IsIconic(handle)) return TRUE;
if (EnumCount >= length(EnumResult)) {
int newlen = 2*length(EnumResult);
REPROTECT(EnumResult = lengthgets(EnumResult, newlen), EnumIndex);
setAttrib(EnumResult, R_NamesSymbol,
lengthgets(getAttrib(EnumResult, R_NamesSymbol), newlen));
}
SET_VECTOR_ELT(EnumResult, EnumCount, R_MakeExternalPtr(handle,R_NilValue,R_NilValue));
if (GetWindowText(handle, title, 1024))
SET_STRING_ELT(getAttrib(EnumResult, R_NamesSymbol), EnumCount, mkChar(title));
EnumCount++;
}
return TRUE;
}
SEXP isoreg(SEXP y)
{
int n = LENGTH(y), i, ip, known, n_ip;
double tmp, slope;
SEXP yc, yf, iKnots, ans;
const char *anms[] = {"y", "yc", "yf", "iKnots", ""};
/* unneeded: y = coerceVector(y, REALSXP); */
PROTECT(ans = mkNamed(VECSXP, anms));
SET_VECTOR_ELT(ans, 0, y);
SET_VECTOR_ELT(ans, 1, yc = allocVector(REALSXP, n+1));
SET_VECTOR_ELT(ans, 2, yf = allocVector(REALSXP, n));
SET_VECTOR_ELT(ans, 3, iKnots= allocVector(INTSXP, n));
/* yc := cumsum(0,y) */
REAL(yc)[0] = 0.;
tmp = 0.;
for (i = 0; i < n; i++) {
tmp += REAL(y)[i];
REAL(yc)[i + 1] = tmp;
}
known = 0; ip = 0, n_ip = 0;
do {
slope = R_PosInf;/*1e+200*/
for (i = known + 1; i <= n; i++) {
tmp = (REAL(yc)[i] - REAL(yc)[known]) / (i - known);
if (tmp < slope) {
slope = tmp;
ip = i;
}
}/* tmp := max{i= kn+1,.., n} slope(p[kn] -> p[i]) and
* ip = argmax{...}... */
INTEGER(iKnots)[n_ip++] = ip;
for (i = known; i < ip; i++)
REAL(yf)[i] = (REAL(yc)[ip] - REAL(yc)[known]) / (ip - known);
} while ((known = ip) < n);
if (n_ip < n)
SET_VECTOR_ELT(ans, 3, lengthgets(iKnots, n_ip));
UNPROTECT(1);
return(ans);
}
// called from package MatrixModels's R code
SEXP dgCMatrix_qrsol(SEXP x, SEXP y, SEXP ord)
{
/* FIXME: extend this to work in multivariate case, i.e. y a matrix with > 1 column ! */
SEXP ycp = PROTECT((TYPEOF(y) == REALSXP) ?
duplicate(y) : coerceVector(y, REALSXP));
CSP xc = AS_CSP(x); /* <--> x may be dgC* or dtC* */
int order = asInteger(ord);
#ifdef _not_yet_do_FIXME__
const char *nms[] = {"L", "coef", "Xty", "resid", ""};
SEXP ans = PROTECT(Rf_mkNamed(VECSXP, nms));
#endif
R_CheckStack();
if (order < 0 || order > 3)
error(_("dgCMatrix_qrsol(., order) needs order in {0,..,3}"));
/* --> cs_amd() --- order 0: natural, 1: Chol, 2: LU, 3: QR */
if (LENGTH(ycp) != xc->m)
error(_("Dimensions of system to be solved are inconsistent"));
/* FIXME? Note that qr_sol() would allow *under-determined systems;
* In general, we'd need LENGTH(ycp) = max(n,m)
* FIXME also: multivariate y (see above)
*/
if (xc->m < xc->n || xc->n <= 0)
error(_("dgCMatrix_qrsol(<%d x %d>-matrix) requires a 'tall' rectangular matrix"),
xc->m, xc->n);
/* cs_qrsol(): Tim Davis (2006) .. "8.2 Using a QR factorization", p.136f , calling
* ------- cs_sqr(order, ..), see p.76 */
/* MM: FIXME: write our *OWN* version of - the first case (m >= n) - of cs_qrsol()
* --------- which will (1) work with a *multivariate* y
* (2) compute coefficients properly, not overwriting RHS
*/
if (!cs_qrsol(order, xc, REAL(ycp)))
/* return value really is 0 or 1 - no more info there */
error(_("cs_qrsol() failed inside dgCMatrix_qrsol()"));
/* Solution is only in the first part of ycp -- cut its length back to n : */
ycp = lengthgets(ycp, (R_len_t) xc->n);
UNPROTECT(1);
return ycp;
}
SEXP attribute_hidden do_lengthgets(SEXP call, SEXP op, SEXP args, SEXP rho)
{
SEXP x, ans;
checkArity(op, args);
check1arg(args, call, "x");
x = CAR(args);
if (PRIMVAL(op)) { /* xlength<- */
if(isObject(x) && DispatchOrEval(call, op, "length<-", args,
rho, &ans, 0, 1))
return(ans);
if (!isVector(x) && !isVectorizable(x))
error(_("invalid argument"));
if (length(CADR(args)) != 1)
error(_("invalid value"));
R_xlen_t len = asVecSize(CADR(args));
return xlengthgets(x, len);
}
if(isObject(x) && DispatchOrEval(call, op, "length<-", args,
rho, &ans, 0, 1))
return(ans);
if (!isVector(x) && !isVectorizable(x))
error(_("invalid argument"));
if (length(CADR(args)) != 1)
error(_("invalid value"));
R_xlen_t len = asVecSize(CADR(args));
if (len < 0) error(_("invalid value"));
if (len > R_LEN_T_MAX) {
#ifdef LONG_VECTOR_SUPPORT
return xlengthgets(x, len);
#else
error(_("vector size specified is too large"));
return x; /* -Wall */
#endif
}
return lengthgets(x, (R_len_t) len);
}
SEXP getWindowsHandles(SEXP which, SEXP minimized)
{
PROTECT_WITH_INDEX(EnumResult = allocVector(VECSXP, 8), &EnumIndex);
setAttrib(EnumResult, R_NamesSymbol, allocVector(STRSXP, 8));
EnumCount = 0;
const char * w;
w = CHAR(STRING_ELT(which, 0));
EnumMinimized = asLogical(minimized);
if (strcmp(w, "R") == 0) EnumProcessId = GetCurrentProcessId();
else EnumProcessId = 0;
if (ismdi() && EnumProcessId)
EnumChildWindows(GetParent(getHandle(RConsole)), EnumWindowsProc, 0);
else
EnumWindows(EnumWindowsProc, 0);
EnumResult = lengthgets(EnumResult, EnumCount);
UNPROTECT(1);
return EnumResult;
}
SEXP graph_bitarray_subGraph(SEXP bits, SEXP _subIndx) {
SEXP _dim = getAttrib(bits,install("bitdim")),
sgVec, btlen, btdim, btcnt, _ftSetPos, res, namesres;
int dim, subLen, prevSetPos = 0, sgSetIndx = 0,
linIndx = 0, col, subgBitLen, subgBytes,
*subIndx, *ftSetPos, edgeCount = 0, ftLen = 256;
PROTECT_INDEX pidx;
unsigned char *bytes = (unsigned char *) RAW(bits), *sgBits;
dim = INTEGER(_dim)[0];
subIndx = INTEGER(_subIndx);
subLen = length(_subIndx);
subgBitLen = subLen * subLen;
subgBytes = subgBitLen / 8;
if ((subgBitLen % 8) != 0) {
subgBytes++;
}
PROTECT(sgVec = allocVector(RAWSXP, subgBytes));
sgBits = RAW(sgVec);
memset(sgBits, 0, subgBytes);
/* TODO: in many cases, this will be more than we need, we should
also use the number of edges in the input as a starting point.
*/
_ftSetPos = allocVector(INTSXP, ftLen); /* FIXME: need better guess */
PROTECT_WITH_INDEX(_ftSetPos, &pidx);
ftSetPos = INTEGER(_ftSetPos);
for (col = 0; col < subLen; col++) {
int col_idx_dim = ((subIndx[col] - 1) * dim) - 1;
int row = 0;
while (row < subLen) {
int setPos = col_idx_dim + subIndx[row];
unsigned char v = bytes[setPos / 8];
if (v != 0 && v & (1 << (setPos % 8))) {
int curSetPos = setPos,
m = prevSetPos;
while (m < curSetPos) {
unsigned char tempV = bytes[m / 8];
if (tempV == 0) {
m += 8;
} else {
if (tempV & (1 << (m % 8))) edgeCount++;
m++;
}
}
prevSetPos = curSetPos + 1;
edgeCount++; /* current edge */
if (sgSetIndx == ftLen) {
ftLen *= 2;
if (ftLen > subgBitLen) ftLen = subgBitLen;
REPROTECT(_ftSetPos = lengthgets(_ftSetPos, ftLen), pidx);
ftSetPos = INTEGER(_ftSetPos);
}
ftSetPos[sgSetIndx] = edgeCount;
sgSetIndx++;
sgBits[linIndx / 8] |= (1 << (linIndx % 8));
}
linIndx++;
row++;
}
}
REPROTECT(_ftSetPos = lengthgets(_ftSetPos, sgSetIndx), pidx);
PROTECT(btlen = ScalarInteger(subgBitLen));
PROTECT(btcnt = ScalarInteger(sgSetIndx));
PROTECT(btdim = allocVector(INTSXP, 2));
INTEGER(btdim)[0] = subLen;
INTEGER(btdim)[1] = subLen;
setAttrib(sgVec, install("bitlen"), btlen);
setAttrib(sgVec, install("bitdim"), btdim);
setAttrib(sgVec, install("nbitset"), btcnt);
PROTECT(res = allocVector(VECSXP, 2));
SET_VECTOR_ELT(res, 0, _ftSetPos);
SET_VECTOR_ELT(res, 1, sgVec);
PROTECT(namesres = allocVector(STRSXP, 2));
SET_STRING_ELT(namesres, 0, mkChar("setPos"));
SET_STRING_ELT(namesres, 1, mkChar("bitVec"));
setAttrib(res, R_NamesSymbol, namesres);
UNPROTECT(7);
return res;
}
/* {{{ rberkeley_dbcursor_get */
SEXP rberkeley_dbcursor_get (SEXP _dbc,
SEXP _key,
SEXP _data,
SEXP _flags,
SEXP _n /* non-API flag */)
{
DBC *dbc;
DBT key, data;
u_int32_t flags;
int i, n, ret, P=0;
flags = (u_int32_t)INTEGER(_flags)[0];
n = (INTEGER(_n)[0] < 0) ? 100 : INTEGER(_n)[0]; /* this should be _all_ data */
dbc = R_ExternalPtrAddr(_dbc);
if(R_ExternalPtrTag(_dbc) != install("DBC") || dbc == NULL)
error("invalid 'dbc' handle");
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
SEXP Keys, Data, results;
PROTECT(Keys = allocVector(VECSXP, n)); P++;
PROTECT(Data = allocVector(VECSXP, n)); P++;
PROTECT(results = allocVector(VECSXP, n)); P++;
/*
Two scenarios for DBcursor->get calls:
(1) key and data are SPECIFIED <OR> key is SPECIFIED, data is EMPTY
(2) key and data are EMPTY
We must handle these seperately in order
to return a sensible result
*/
if( (!isNull(_key) &&
!isNull(_data)) || !isNull(_key) ) {
/* need to handle cases where multiple results
can be returned. Possibly given that flag
we can instead use the last if-else branch */
key.data = (unsigned char *)RAW(_key);
key.size = length(_key);
if(!isNull(_data)) {
data.data = (unsigned char *)RAW(_data);
data.size = length(_data);
}
ret = dbc->get(dbc, &key, &data, flags);
if(ret == 0) {
SEXP KeyData;
PROTECT(KeyData = allocVector(VECSXP, 2));P++;
SEXP rawkey;
PROTECT(rawkey = allocVector(RAWSXP, key.size));
memcpy(RAW(rawkey), key.data, key.size);
SET_VECTOR_ELT(KeyData, 0, rawkey);
UNPROTECT(1);
SEXP rawdata;
PROTECT(rawdata = allocVector(RAWSXP, data.size));
memcpy(RAW(rawdata), data.data, data.size);
SET_VECTOR_ELT(KeyData, 1, rawdata);
UNPROTECT(1);
SEXP KeyDataNames;
PROTECT(KeyDataNames = allocVector(STRSXP,2)); P++;
SET_STRING_ELT(KeyDataNames, 0, mkChar("key"));
SET_STRING_ELT(KeyDataNames, 1, mkChar("data"));
setAttrib(KeyData, R_NamesSymbol, KeyDataNames);
SET_VECTOR_ELT(results, 0, KeyData);
PROTECT(results = lengthgets(results, 1)); P++;
}
} else
if(isNull(_key) && isNull(_data)) {
for(i = 0; i < n; i++) {
ret = dbc->get(dbc, &key, &data, flags);
if(ret == 0) {
SEXP KeyData;
PROTECT(KeyData = allocVector(VECSXP, 2));
SEXP rawkey;
PROTECT(rawkey = allocVector(RAWSXP, key.size));
memcpy(RAW(rawkey), key.data, key.size);
SET_VECTOR_ELT(KeyData, 0, rawkey);
SEXP rawdata;
PROTECT(rawdata = allocVector(RAWSXP, data.size));
memcpy(RAW(rawdata), data.data, data.size);
SET_VECTOR_ELT(KeyData, 1, rawdata);
SEXP KeyDataNames;
PROTECT(KeyDataNames = allocVector(STRSXP,2));
SET_STRING_ELT(KeyDataNames, 0, mkChar("key"));
SET_STRING_ELT(KeyDataNames, 1, mkChar("data"));
setAttrib(KeyData, R_NamesSymbol, KeyDataNames);
SET_VECTOR_ELT(results, i, KeyData);
UNPROTECT(4); /* KeyDataNames, rawdata, rawkey, KeyData */
} else { /* end of data */
if(i == 0) { /* no results */
UNPROTECT(P);
return ScalarInteger(ret);
}
/* truncate the keys and data to the i-size found */
PROTECT(results = lengthgets(results, i)); P++;
break;
}
}
}
UNPROTECT(P);
return results;
}
SEXP non_duplicates (SEXP x_, SEXP fromLast_) {
int fromLast = asLogical(fromLast_),
i, d=0,
len = length(x_);
int *x_int;
double *x_real;
SEXP duplicates;
int *duplicates_int;
/* need to reprotect lengthgets() result before returning */
PROTECT_INDEX idx;
PROTECT_WITH_INDEX(duplicates = allocVector(INTSXP, len), &idx);
duplicates_int = INTEGER(duplicates);
if(!fromLast) { /* keep first observation */
duplicates_int[0] = ++d;
switch(TYPEOF(x_)) {
case INTSXP:
x_int = INTEGER(x_);
for(i=1; i < len-1; i++) {
if( x_int[i-1] != x_int[i]) {
#ifdef DEBUG
Rprintf("i=%i: x[i-1]=%i, x[i]=%i\n",i,x_int[i-1],x_int[i]);
#endif
duplicates_int[d++] = i+1;
}
}
break;
case REALSXP:
x_real = REAL(x_);
for(i=1; i < len; i++) {
/*
if( x_real[i-1] == x_real[i])
duplicates_int[d++] = (int)(-1*(i+1));
*/
if( x_real[i-1] != x_real[i])
duplicates_int[d++] = i+1;
}
break;
default:
error("only numeric types supported");
break;
}
} else { /* keep last observation */
switch(TYPEOF(x_)) {
case INTSXP:
x_int = INTEGER(x_);
for(i=1; i < len; i++) {
if( x_int[i-1] != x_int[i])
duplicates_int[d++] = i;
}
break;
case REALSXP:
x_real = REAL(x_);
for(i=1; i < len; i++) {
if( x_real[i-1] != x_real[i])
duplicates_int[d++] = i;
}
break;
default:
error("only numeric types supported");
break;
}
duplicates_int[d++] = len;
}
REPROTECT(duplicates = lengthgets(duplicates, d), idx);
UNPROTECT(1);
return(duplicates);
}
SEXP readSlicePorStream(SEXP porStream, SEXP what, SEXP s_vars, SEXP s_cases, SEXP s_types){
porStreamBuf *b = get_porStreamBuf(porStream);
PROTECT(s_vars = coerceVector(s_vars,LGLSXP));
PROTECT(s_cases = coerceVector(s_cases,LGLSXP));
PROTECT(s_types = coerceVector(s_types,INTSXP));
int nvar = length(s_types);
int ncases = length(s_cases);
int *types = INTEGER(s_types);
if(LENGTH(s_vars)!=nvar) error("\'s_vars\' argument has wrong length");
int ii,i,j,k, m=0, n = 0;
for(j = 0; j < nvar; j++) m+=LOGICAL(s_vars)[j];
for(i = 0; i < ncases; i++) n+=LOGICAL(s_cases)[i];
SEXP x, y, data;
char *charbuf;
int charbuflen = 0;
PROTECT(data = allocVector(VECSXP,m));
k = 0;
for(j = 0; j < nvar; j++){
if(types[j] > charbuflen) charbuflen = types[j];
if(LOGICAL(s_vars)[j]){
if(types[j]==0)
SET_VECTOR_ELT(data,k,allocVector(REALSXP,n));
else {
SET_VECTOR_ELT(data,k,allocVector(STRSXP,n));
}
k++;
}
}
charbuf = R_alloc(charbuflen+1,sizeof(char));
ii = 0;
for(i = 0; i < ncases; i++){
if(atEndPorStream(b) || (b->pos < 80 && b->buf[b->pos] == 'Z')){
int new_length = ii;
for(j = 0; j < m; j++){
x = VECTOR_ELT(data,j);
SET_VECTOR_ELT(data,j,lengthgets(x,new_length));
}
n = new_length;
break;
}
if(LOGICAL(s_cases)[i]){
k = 0;
for(j = 0; j < nvar; j++){
if(atEndPorStream(b)) {
printPorStreamBuf(b);
warning("\nPremature end of data");
}
if(types[j]==0){
if(LOGICAL(s_vars)[j]){
REAL(VECTOR_ELT(data,k))[ii] = readDoublePorStream1(b);
k++;
}
else {
readDoublePorStream1(b);
}
}
else {
if(LOGICAL(s_vars)[j]){
SET_STRING_ELT(VECTOR_ELT(data,k), ii,
mkChar(readCHARPorStream(b,charbuf,types[j])));
k++;
}
else {
readCHARPorStream(b,charbuf,types[j]);
}
}
}
ii++;
}
else {
for(j = 0; j < nvar; j++){
if(atEndPorStream(b)) {
printPorStreamBuf(b);
error("\nPremature end of data");
}
if(types[j]==0) readDoublePorStream1(b);
else readCHARPorStream(b,charbuf,types[j]);
}
}
}
k = 0;
for(j = 0; j < nvar; j++){
if(LOGICAL(s_vars)[j]){
x = VECTOR_ELT(what,j);
y = VECTOR_ELT(data,k);
copyMostAttrib(x,y);
k++;
}
}
UNPROTECT(4);
return data;
}
static SEXP
read_SPSS_PORT(const char *filename)
{
struct file_handle *fh = fh_get_handle_by_filename(filename);
struct pfm_read_info inf;
struct dictionary *dict = pfm_read_dictionary(fh, &inf);
SEXP ans = PROTECT(allocVector(VECSXP, dict->nvar));
SEXP ans_names = PROTECT(allocVector(STRSXP, dict->nvar));
union value *case_vals;
int i;
int ncases = 0;
int N = 10;
int nval = 0;
int nvar_label;
SEXP val_labels;
SEXP variable_labels;
SEXP miss_labels; int have_miss = 0;
/* Set the fv and lv elements of all variables in the
dictionary. */
for (i = 0; i < dict->nvar; i++) {
struct variable *v = dict->var[i];
v->fv = nval;
nval += v->nv;
}
dict->nval = nval;
if (!nval)
error(_("nval is 0"));
case_vals = (union value *) R_alloc(dict->nval, sizeof(union value));
for (i = 0; i < dict->nvar; i++) {
struct variable *v = dict->var[i];
if (v->get.fv == -1)
continue;
SET_STRING_ELT(ans_names, i, mkChar(dict->var[i]->name));
if (v->type == NUMERIC) {
SET_VECTOR_ELT(ans, i, allocVector(REALSXP, N));
} else {
SET_VECTOR_ELT(ans, i, allocVector(STRSXP, N));
case_vals[v->fv].c =
(unsigned char *) R_alloc(v->width + 1, 1);
((char *) &case_vals[v->fv].c[0])[v->width] = '\0';
}
}
while(pfm_read_case(fh, case_vals, dict)) {
if (ncases == N) {
N *= 2;
for (i = 0; i < dict->nvar; i++) {
SEXP elt = VECTOR_ELT(ans, i);
elt = lengthgets(elt, N);
SET_VECTOR_ELT(ans, i, elt);
}
}
for (i = 0; i < dict->nvar; i++) {
struct variable *v = dict->var[i];
if (v->get.fv == -1)
continue;
if (v->type == NUMERIC) {
REAL(VECTOR_ELT(ans, i))[ncases] = case_vals[v->fv].f;
} else {
SET_STRING_ELT(VECTOR_ELT(ans, i), ncases,
mkChar((char *)case_vals[v->fv].c));
}
}
++ncases;
}
if (N != ncases) {
for (i = 0; i < dict->nvar; i++) {
SEXP elt = VECTOR_ELT(ans, i);
elt = lengthgets(elt, ncases);
SET_VECTOR_ELT(ans, i, elt);
}
}
fh_close_handle(fh);
/* get all the value labels */
PROTECT(val_labels = getSPSSvaluelabels(dict));
namesgets(val_labels, ans_names);
setAttrib(ans, install("label.table"), val_labels);
UNPROTECT(1);
/* get SPSS variable labels */
PROTECT(variable_labels = allocVector(STRSXP, dict->nvar));
nvar_label = 0;
for (i = 0; i < dict->nvar; i++) {
char *lab = dict->var[i]->label;
if (lab != NULL) {
nvar_label++;
SET_STRING_ELT(variable_labels, i, mkChar(lab));
}
}
if (nvar_label > 0) {
namesgets(variable_labels, ans_names);
setAttrib(ans, install("variable.labels"), variable_labels);
}
UNPROTECT(1);
/* report missingness */
PROTECT(miss_labels = getSPSSmissing(dict, &have_miss));
if(have_miss) {
namesgets(miss_labels, duplicate(ans_names));
setAttrib(ans, install("missings"), miss_labels);
}
UNPROTECT(1);
free_dictionary(dict);
setAttrib(ans, R_NamesSymbol, ans_names);
UNPROTECT(2);
return ans;
}
SEXP readfixedsubset(SEXP s_file, SEXP what, SEXP s_vars, SEXP s_cases, SEXP s_start, SEXP s_stop){
FILE *f = rofile_FILE(s_file);
PROTECT(s_vars = coerceVector(s_vars,LGLSXP));
PROTECT(s_cases = coerceVector(s_cases,LGLSXP));
PROTECT(s_start = coerceVector(s_start,INTSXP));
PROTECT(s_stop = coerceVector(s_stop,INTSXP));
if(LENGTH(s_start) != LENGTH(s_stop)) error("start and stop must have equal length");
if(LENGTH(s_vars) != LENGTH(s_stop)) error("vars argument has wrong length");
int m = 0, n = 0;
int nvar = LENGTH(what);
int ncases = LENGTH(s_cases);
int ii,i,j,k;
for(i = 0; i < LENGTH(s_cases); i++) n += LOGICAL(s_cases)[i];
for(j = 0; j < LENGTH(s_vars); j++) m += LOGICAL(s_vars)[j];
int *start = INTEGER(s_start);
int *stop = INTEGER(s_stop);
int max_lenline = stop[nvar-1];
char *buffer = R_alloc(max_lenline+3,1);
char *item, *currdata;
SEXP data;
PROTECT(data = allocVector(VECSXP,m));
SEXP x, y;
int *length = (int *) R_alloc(nvar,sizeof(int));
int maxlen = 0;
k = 0;
for(j = 0; j < nvar; j++){
length[j] = stop[j] - start[j] + 1;
if(LOGICAL(s_vars)[j]){
if(maxlen < length[j]) maxlen = length[j];
x = VECTOR_ELT(what,j);
SET_VECTOR_ELT(data,k,lengthgets(x,n));
k++;
}
}
item = R_alloc(maxlen+1,1);
ii = 0;
for(i = 0; i < ncases; i++){
memset(buffer,0,max_lenline+3);
buffer = fgets(buffer,max_lenline+3,f);
#ifdef DEBUG
Rprintf("Requested line length: %d\n",max_lenline);
Rprintf("Actual line length: %d\n",strlen(buffer));
Rprintf("Buffer: >>%s<<\n",buffer);
#endif
if(strlen(buffer)< max_lenline) {
int new_length = i;
for(j = 0; j < nvar; j++){
x = VECTOR_ELT(data,j);
SET_VECTOR_ELT(data,j,lengthgets(x,new_length));
}
n = new_length;
break;
}
if(LOGICAL(s_cases)[i]){
currdata = buffer;
k = 0;
for(j = 0; j < nvar; j++){
currdata = buffer + start[j]-1;
if(LOGICAL(s_vars)[j]){
x = VECTOR_ELT(data,k);
memset(item,0,maxlen+1);
memcpy(item,currdata,length[j]);
trim(item,length[j]);
#ifdef DEBUG
Rprintf("Item: >>%s<<\n",item);
#endif
#undef DEBUG
if(TYPEOF(x)==INTSXP)
INTEGER(x)[ii] = _R_atoi(item);
else if (TYPEOF(x)==REALSXP)
REAL(x)[ii] = _R_atof(item);
else
SET_STRING_ELT(x,ii,mkChar(item));
k++;
}
}
ii++;
}
}
k = 0;
for(j = 0; j < nvar; j++){
if(LOGICAL(s_vars)[j]){
x = VECTOR_ELT(what,j);
y = VECTOR_ELT(data,k);
copyMostAttrib(x,y);
k++;
}
}
UNPROTECT(5);
return data;
}
SEXP readDataPorStream(SEXP porStream, SEXP what, SEXP s_n, SEXP s_types){
#ifdef DEBUG
Rprintf("\n############################");
Rprintf("\n#readDataPorStream");
Rprintf("\n############################");
#endif
porStreamBuf *b = get_porStreamBuf(porStream);
int n = asInteger(s_n);
#ifdef DEBUG
Rprintf("\nRequired number of cases: %d",n);
Rprintf("\nBuffer contents: |%s|",b->buf);
Rprintf("\nLine: %d",b->line);
Rprintf("\nPosition: %d",b->pos);
Rprintf("\nBuffer remainder: %s",b->buf + b->pos);
#endif
PROTECT(s_types = coerceVector(s_types,INTSXP));
int nvar = length(s_types);
int *types = INTEGER(s_types);
SEXP x, y, data;
char *charbuf;
int charbuflen = 0;
PROTECT(data = allocVector(VECSXP,nvar));
int i,j;
for(j = 0; j < nvar; j++){
if(types[j]==0)
SET_VECTOR_ELT(data,j,allocVector(REALSXP,n));
else {
SET_VECTOR_ELT(data,j,allocVector(STRSXP,n));
if(types[j] > charbuflen) charbuflen = types[j];
}
}
charbuf = R_alloc(charbuflen+1,sizeof(char));
#ifdef DEBUG
// PrintValue(data);
#endif
for(i = 0; i < n; i++){
if(atEndPorStream(b) || (b->pos < 80 && b->buf[b->pos] == 'Z')){
#ifdef DEBUG
Rprintf("\nReached end of cases at i=%d",i);
#endif
int new_length = i;
for(j = 0; j < nvar; j++){
x = VECTOR_ELT(data,j);
SET_VECTOR_ELT(data,j,lengthgets(x,new_length));
}
n = new_length;
break;
}
#ifdef DEBUG
Rprintf("\nCase number: %d\n",i);
#endif
for(j = 0; j < nvar; j++){
if(atEndPorStream(b)) {
printPorStreamBuf(b);
warning("\nPremature end of data");
break;
}
#ifdef DEBUG
PrintValue(VECTOR_ELT(data,j));
#endif
if(types[j]==0) REAL(VECTOR_ELT(data,j))[i] = readDoublePorStream1(b);
else SET_STRING_ELT(VECTOR_ELT(data,j), i,
mkChar(readCHARPorStream(b,charbuf,types[j])));
#ifdef DEBUG
if(i<3 && types[j]>0)
PrintValue(STRING_ELT(VECTOR_ELT(data,j),i));
#endif
}
}
for(j = 0; j < nvar; j++){
x = VECTOR_ELT(what,j);
y = VECTOR_ELT(data,j);
copyMostAttrib(x,y);
}
UNPROTECT(2);
return data;
}
SEXP readfixed(SEXP s_file, SEXP what, SEXP s_nlines, SEXP s_start, SEXP s_stop){
PROTECT(s_start = coerceVector(s_start,INTSXP));
PROTECT(s_stop = coerceVector(s_stop,INTSXP));
FILE *f = rofile_FILE(s_file);
if(LENGTH(s_start) != LENGTH(s_stop)) error("start and stop must have equal length");
int n = asInteger(s_nlines);
int nvar = LENGTH(s_start);
int *start = INTEGER(s_start);
int *stop = INTEGER(s_stop);
int max_lenline = stop[nvar-1];
char *buffer = R_alloc(max_lenline+3,1);
char *item, *currdata;
SEXP data;
PROTECT(data=allocVector(VECSXP,nvar));
int i,j;
int *length = (int *) R_alloc(nvar,sizeof(int));
int maxlen = 0;
SEXP x,y;
for(j = 0; j < nvar; j++){
length[j] = stop[j] - start[j] + 1;
if(maxlen < length[j]) maxlen = length[j];
x = VECTOR_ELT(what,j);
SET_VECTOR_ELT(data,j,lengthgets(x,n));
}
item = R_alloc(maxlen+1,1);
#undef DEBUG
#ifdef DEBUG
Rprintf("Requested number of lines: %d\n",n);
#endif
for(i = 0; i < n; i++){
memset(buffer,0,max_lenline+3);
buffer = fgets(buffer,max_lenline+3,f);
#ifdef DEBUG
Rprintf("Requested line length: %d\n",max_lenline);
Rprintf("Actual line length: %d\n",strlen(buffer));
if(i == 0)
Rprintf("Buffer: >>%s<<\n",buffer);
#endif
if(strlen(buffer)< max_lenline) {
int new_length = i;
for(j = 0; j < nvar; j++){
x = VECTOR_ELT(data,j);
SET_VECTOR_ELT(data,j,lengthgets(x,new_length));
}
n = new_length;
break;
}
currdata = buffer;
for(j = 0; j < nvar; j++){
x = VECTOR_ELT(data,j);
currdata = buffer + start[j]-1;
memset(item,0,maxlen+1);
memcpy(item,currdata,length[j]);
trim(item,length[j]);
#undef DEBUG
if(TYPEOF(x)==INTSXP)
INTEGER(x)[i] = _R_atoi(item);
else if (TYPEOF(x)==REALSXP)
REAL(x)[i] = _R_atof(item);
else
SET_STRING_ELT(x,i,mkChar(item));
}
}
for(j = 0; j < nvar; j++){
x = VECTOR_ELT(what,j);
y = VECTOR_ELT(data,j);
copyMostAttrib(x,y);
}
UNPROTECT(3);
return data;
}
//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;
int no_duplicate = LOGICAL(dup)[0];
int 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;
int *int_result=NULL, *int_x=NULL, *int_y=NULL;
int *int_newindex=NULL, *int_xindex=NULL, *int_yindex=NULL;
double *real_result=NULL, *real_x=NULL, *real_y=NULL;
double *real_newindex=NULL, *real_xindex=NULL, *real_yindex=NULL;
nrx = nrows(x);
ncx = ncols(x);
nry = nrows(y);
ncy = ncols(y);
truelen = len = nrx + nry;
if( isNull(x) || isNull(y) ) {
/* Handle NULL values by returning non-null object */
if(!isNull(x)) return x;
return y;
}
if( !isXts(x) ) {
PROTECT( x = tryXts(x) ); P++;
}
if( !isXts(y) ) {
PROTECT( y = tryXts(y) ); P++;
}
/* need to convert different types of x and y if needed */
if( TYPEOF(x) != TYPEOF(y) ) {
warning("mismatched types: converting objects to numeric"); // FIXME not working!!!????
PROTECT(x = coerceVector(x, REALSXP)); P++;
PROTECT(y = coerceVector(y, REALSXP)); P++;
}
mode = TYPEOF(x);
if(ncx != ncy)
error("data must have same number of columns to bind by row");
PROTECT(xindex = getAttrib(x, xts_IndexSymbol)); P++;
PROTECT(yindex = getAttrib(y, xts_IndexSymbol)); P++;
if( TYPEOF(xindex) != TYPEOF(yindex) )
{
PROTECT(xindex = coerceVector(xindex, REALSXP)); P++;
PROTECT(yindex = coerceVector(yindex, REALSXP)); P++;
}
#ifdef RBIND_APPEND
if(TYPEOF(xindex)==REALSXP) {
if(REAL(xindex)[length(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]) {
UNPROTECT(P);
return rbind_append(x,y);
}
}
#endif
PROTECT(newindex = allocVector(TYPEOF(xindex), len)); P++;
PROTECT(result = allocVector(TYPEOF(x), len * ncx)); P++;
copyMostAttrib(xindex, newindex);
switch( TYPEOF(x) ) {
case INTSXP:
int_x = INTEGER(x);
int_y = INTEGER(y);
int_result = INTEGER(result);
break;
case REALSXP:
real_x = REAL(x);
real_y = REAL(y);
real_result = REAL(result);
break;
default:
break;
}
/*
if( TYPEOF(xindex) == REALSXP ) {
if(REAL(xindex)[nrx-1] < REAL(yindex)[0]) {
memcpy(REAL(newindex), REAL(xindex), sizeof(double) * nrx);
memcpy(REAL(newindex)+nrx, REAL(yindex), sizeof(double) * nry);
switch(TYPEOF(x)) {
case INTSXP:
memcpy(INTEGER(result), INTEGER(x), sizeof(int) * (nrx*ncx));
memcpy(INTEGER(result)+(nrx*ncx), INTEGER(y), sizeof(int) * (nry*ncy));
break;
case REALSXP:
memcpy(REAL(result), REAL(x), sizeof(double) * (nrx*ncx));
memcpy(REAL(result)+(nrx*ncx), REAL(y), sizeof(double) * (nry*ncy));
break;
default:
break;
}
UNPROTECT(P);
return(result);
}
} else {
}
*/
/*
The main body of code to follow branches based on the type
of index, removing the need to test at each position.
*/
if( TYPEOF(xindex) == REALSXP ) {
real_newindex = REAL(newindex);
real_xindex = REAL(xindex);
real_yindex = REAL(yindex);
for( i = 0; i < len; i++ ) {
if( i >= truelen ) {
break;
} else
if( xp > nrx ) {
real_newindex[ i ] = real_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
yp++;
} else
if( yp > nry ) {
real_newindex[ i ] = real_xindex[ xp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
break;
default:
break;
}
}
xp++;
} else
if( real_xindex[ xp-1 ] == real_yindex[ yp-1 ] ) {
if( real_xindex[ xp-1 ] < real_xindex[ xp ] )
add_y = 1; /* add y values only if next xindex is new */
if(no_duplicate) {
add_y = 0;
truelen--;
}
real_newindex[ i ] = real_xindex[ xp-1 ];
if(add_y) real_newindex[ i+ 1 ] = real_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
if(add_y) LOGICAL(result)[ ij+1 ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
if(add_y) int_result[ ij+1 ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
if(add_y) real_result[ ij+1 ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
if(add_y) COMPLEX(result)[ ij+1 ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
if(add_y) SET_STRING_ELT(result, ij+1, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
xp++;
if(no_duplicate || add_y) {
yp++;
if(!no_duplicate) i++; // need to increase i as we now have filled in 2 values
add_y = 0;
}
} else
if( real_xindex[ xp-1 ] < real_yindex[ yp-1 ] ) {
real_newindex[ i ] = real_xindex[ xp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
break;
default:
break;
}
}
xp++;
} else
if( real_xindex[ xp-1 ] > real_yindex[ yp-1 ] ) {
real_newindex[ i ] = real_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
yp++;
}
}
} else
if( TYPEOF(xindex) == INTSXP ) {
int_newindex = INTEGER(newindex);
int_xindex = INTEGER(xindex);
int_yindex = INTEGER(yindex);
for(i = 0; i < len; i++) {
/*Rprintf("xp:%i, yp:%i, i:%i\n",xp,yp,i);*/
if( i >= truelen ) {
break;
} else
if( xp > nrx ) {
int_newindex[ i ] = int_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
yp++;
} else
if( yp > nry ) {
int_newindex[ i ] = int_xindex[ xp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
break;
default:
break;
}
}
xp++;
} else
if( int_xindex[ xp-1 ] == int_yindex[ yp-1 ] ) {
if( int_xindex[ xp-1 ] < int_xindex[ xp ] )
add_y = 1;
if(no_duplicate) {
add_y = 0;
truelen--;
}
int_newindex[ i ] = int_xindex[ xp-1 ];
if(add_y) int_newindex[ i+1 ] = int_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
if(add_y) LOGICAL(result)[ ij+1 ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
if(add_y) int_result[ ij+1 ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
if(add_y) real_result[ ij+1 ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
if(add_y) COMPLEX(result)[ ij+1 ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
if(add_y) SET_STRING_ELT(result, ij+1, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
xp++;
if(no_duplicate || add_y) {
yp++;
if(!no_duplicate) i++; // need to increase i as we now have filled in 2 values
add_y = 0;
}
} else
if( int_xindex[ xp-1 ] < int_yindex[ yp-1 ] ) {
int_newindex[ i ] = int_xindex[ xp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
break;
default:
break;
}
}
xp++;
} else
if( int_xindex[ xp-1 ] > int_yindex[ yp-1 ] ) {
int_newindex[ i ] = int_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
yp++;
}}
}
if(truelen != len) {
PROTECT(result = lengthgets(result, truelen * ncx)); P++; /* reset length */
}
setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
SEXP dim;
PROTECT(dim = allocVector(INTSXP, 2));
INTEGER(dim)[0] = truelen;
INTEGER(dim)[1] = INTEGER(getAttrib(x, R_DimSymbol))[1];
UNPROTECT(1);
setAttrib(result, R_DimSymbol, dim);
setAttrib(result, R_DimNamesSymbol, getAttrib(x, R_DimNamesSymbol));
if(truelen != len) {
PROTECT(newindex = lengthgets(newindex, truelen)); P++;
}
setAttrib(result, xts_IndexSymbol, newindex);
setAttrib(result, xts_IndexClassSymbol, getAttrib(x, xts_IndexClassSymbol));
setAttrib(result, xts_IndexTZSymbol, getAttrib(x, xts_IndexTZSymbol));
setAttrib(result, xts_IndexFormatSymbol, getAttrib(x, xts_IndexFormatSymbol));
setAttrib(result, xts_ClassSymbol, getAttrib(x, xts_ClassSymbol));
copy_xtsAttributes(x, result);
UNPROTECT(P);
return result;
} //}}}
