The R Project SVN – R – Diff – /branches/R-GenGC/src/main/array.c



/* grabbed off an array it is always adjusted to be a vector. */
 
SEXP GetRowNames(SEXP dimnames)
{
    if (TYPEOF(dimnames) == VECSXP)
	return VECTOR_ELT(dimnames, 0);
    else if (TYPEOF(dimnames) == LISTSXP)
	return CAR(dimnames);
    else
	return R_NilValue;
}
 
SEXP GetColNames(SEXP dimnames)
{
    if (TYPEOF(dimnames) == VECSXP)
	return VECTOR_ELT(dimnames, 1);
    else if (TYPEOF(dimnames) == LISTSXP)
	return CADR(dimnames);
    else
	return R_NilValue;
}

	if (dimnames != R_NilValue) {
	    n = length(dims);
	    if (TYPEOF(dimnames) == VECSXP) {
		for (i = 0; i < n; i++) {
		    if (INTEGER(dims)[i] != 1) {
			newnames = VECTOR_ELT(dimnames, i);
			break;
		    }
		}
	    }
	    else {

	    if (INTEGER(dims)[i] != 1)
		INTEGER(newdims)[n++] = INTEGER(dims)[i];
	if (!isNull(dimnames)) {
	    int havenames = 0;
	    for (i = 0; i < ndims; i++)
		if (INTEGER(dims)[i] != 1 &&
		    VECTOR_ELT(dimnames, i) != R_NilValue)
		    havenames = 1;
	    if (havenames) {
		PROTECT(newnames = allocVector(VECSXP, n));
		PROTECT(newnamesnames = allocVector(STRSXP, n));
		for (i = 0, n = 0; i < ndims; i++) {
		    if (INTEGER(dims)[i] != 1) {
			if(!isNull(dnn))
			    SET_STRING_ELT(newnamesnames, n,
					   STRING_ELT(dnn, i));
			SET_VECTOR_ELT(newnames, n++, VECTOR_ELT(dimnames, i));
		    }
		}
	    }
	    else dimnames = R_NilValue;
	}

 
    if (isComplex(CAR(args)) || isComplex(CADR(args)))
	mode = CPLXSXP;
    else
	mode = REALSXP;
    SETCAR(args, coerceVector(CAR(args), mode));
    SETCADR(args, coerceVector(CADR(args), mode));
 
    if (PRIMVAL(op) == 0) {
	PROTECT(ans = allocMatrix(mode, nrx, ncy));
	if (mode == CPLXSXP)
	    cmatprod(COMPLEX(CAR(args)), nrx, ncx,

	    PROTECT(dimnames = allocVector(VECSXP, 2));
	    PROTECT(dimnamesnames = allocVector(STRSXP, 2));
	    if (xdims != R_NilValue) {
		if (ldx == 2 || ncx ==1) {
		    dn = getAttrib(xdims, R_NamesSymbol);
		    SET_VECTOR_ELT(dimnames, 0, VECTOR_ELT(xdims, 0));
		    if(!isNull(dn))
			SET_STRING_ELT(dimnamesnames, 0, STRING_ELT(dn, 0));
		}
	    }
	    if (ydims != R_NilValue) {
		if (ldy == 2 ){
		    dn = getAttrib(ydims, R_NamesSymbol);
		    SET_VECTOR_ELT(dimnames, 1, VECTOR_ELT(ydims, 1));
		    if(!isNull(dn))
			SET_STRING_ELT(dimnamesnames, 1, STRING_ELT(dn, 1));
		} else if (nry == 1) {
		    dn = getAttrib(ydims, R_NamesSymbol);
		    SET_VECTOR_ELT(dimnames, 1, VECTOR_ELT(ydims, 0));
		    if(!isNull(dn))
			SET_STRING_ELT(dimnamesnames, 1, STRING_ELT(dn, 0));
		}
	    }
	    setAttrib(dimnames, R_NamesSymbol, dimnamesnames);
	    setAttrib(ans, R_DimNamesSymbol, dimnames);
	    UNPROTECT(2);

	    SEXP dimnames, dimnamesnames, dnx=R_NilValue, dny=R_NilValue;
	    PROTECT(dimnames = allocVector(VECSXP, 2));
	    PROTECT(dimnamesnames = allocVector(STRSXP, 2));
	    if (xdims != R_NilValue) {
		dnx = getAttrib(xdims, R_NamesSymbol);
		SET_VECTOR_ELT(dimnames, 0, VECTOR_ELT(xdims, 1));
		if(!isNull(dnx))
		    SET_STRING_ELT(dimnamesnames, 0, STRING_ELT(dnx, 1));
	    }
	    if (ydims != R_NilValue) {
		dny = getAttrib(ydims, R_NamesSymbol);
		SET_VECTOR_ELT(dimnames, 1, VECTOR_ELT(ydims, 1));
		if(!isNull(dny))
		    SET_STRING_ELT(dimnamesnames, 1, STRING_ELT(dny, 1));
	    }
	    if (!isNull(dnx) || !isNull(dny))
		setAttrib(dimnames, R_NamesSymbol, dimnamesnames);
	    setAttrib(ans, R_DimNamesSymbol, dimnames);
	    UNPROTECT(2);

	case 1:
	    nrow = len = length(a);
	    ncol = 1;
	    rnames = getAttrib(a, R_DimNamesSymbol);
	    if (rnames != R_NilValue)
		rnames = VECTOR_ELT(rnames, 0);
	    break;
	case 2:
	    ncol = ncols(a);
	    nrow = nrows(a);
	    len = length(a);
	    dimnames = getAttrib(a, R_DimNamesSymbol);
	    if (dimnames != R_NilValue) {
		rnames = VECTOR_ELT(dimnames, 0);
		cnames = VECTOR_ELT(dimnames, 1);
		dimnamesnames = getAttrib(dimnames, R_NamesSymbol);
	    }
	    break;
	default:
	    goto not_matrix;

	for (i = 0; i < len; i++)
	    COMPLEX(r)[i] = COMPLEX(a)[(i / ncol) + (i % ncol) * nrow];
	break;
    case STRSXP:
	for (i = 0; i < len; i++)
	    SET_STRING_ELT(r, i,
			   STRING_ELT(a, (i / ncol) + (i % ncol) * nrow));
	break;
    case VECSXP:
	for (i = 0; i < len; i++)
	    SET_VECTOR_ELT(r, i,
			   VECTOR_ELT(a, (i / ncol) + (i % ncol) * nrow));
	break;
    default:
	goto not_matrix;
    }
    PROTECT(dims = allocVector(INTSXP, 2));

    INTEGER(dims)[1] = nrow;
    setAttrib(r, R_DimSymbol, dims);
    UNPROTECT(1);
    if(rnames != R_NilValue || cnames != R_NilValue) {
	PROTECT(dimnames = allocVector(VECSXP, 2));
	SET_VECTOR_ELT(dimnames, 0, cnames);
	SET_VECTOR_ELT(dimnames, 1, rnames);
	if(!isNull(dimnamesnames)) {
	    PROTECT(ndimnamesnames = allocVector(VECSXP, 2));
	    SET_STRING_ELT(ndimnamesnames, 1, STRING_ELT(dimnamesnames, 0));
	    SET_STRING_ELT(ndimnamesnames, 0, STRING_ELT(dimnamesnames, 1));
	    setAttrib(dimnames, R_NamesSymbol, ndimnamesnames);
	    UNPROTECT(1);
	}
	setAttrib(r, R_DimNamesSymbol, dimnames);
	UNPROTECT(1);

	}
	break;
    case STRSXP:
	for (i = 0; i < len; i++) {
	    j = swap(i, dimsa, dimsr, perm, ind1, ind2);
	    SET_STRING_ELT(r, j, STRING_ELT(a, i));
	}
	break;
    case VECSXP:
	for (i = 0; i < len; i++) {
	    j = swap(i, dimsa, dimsr, perm, ind1, ind2);
	    SET_VECTOR_ELT(r, j, VECTOR_ELT(a, i));
	}
    default:
	errorcall(call, R_MSG_IA);
    }
 

Rev 9615	Rev 9642
Line 35...	Line 35...
35	`/* grabbed off an array it is always adjusted to be a vector. */`	35	`/* grabbed off an array it is always adjusted to be a vector. */`
36		36
37	`SEXP GetRowNames(SEXP dimnames)`	37	`SEXP GetRowNames(SEXP dimnames)`
38	`{`	38	`{`
39	`if (TYPEOF(dimnames) == VECSXP)`	39	`if (TYPEOF(dimnames) == VECSXP)`
40	`return VECTOR(dimnames)[0];`	40	`return VECTOR_ELT(dimnames, 0);`
41	`else if (TYPEOF(dimnames) == LISTSXP)`	41	`else if (TYPEOF(dimnames) == LISTSXP)`
42	`return CAR(dimnames);`	42	`return CAR(dimnames);`
43	`else`	43	`else`
44	`return R_NilValue;`	44	`return R_NilValue;`
45	`}`	45	`}`
46		46
47	`SEXP GetColNames(SEXP dimnames)`	47	`SEXP GetColNames(SEXP dimnames)`
48	`{`	48	`{`
49	`if (TYPEOF(dimnames) == VECSXP)`	49	`if (TYPEOF(dimnames) == VECSXP)`
50	`return VECTOR(dimnames)[1];`	50	`return VECTOR_ELT(dimnames, 1);`
51	`else if (TYPEOF(dimnames) == LISTSXP)`	51	`else if (TYPEOF(dimnames) == LISTSXP)`
52	`return CADR(dimnames);`	52	`return CADR(dimnames);`
53	`else`	53	`else`
54	`return R_NilValue;`	54	`return R_NilValue;`
55	`}`	55	`}`
Line 175...	Line 175...
175	`if (dimnames != R_NilValue) {`	175	`if (dimnames != R_NilValue) {`
176	`n = length(dims);`	176	`n = length(dims);`
177	`if (TYPEOF(dimnames) == VECSXP) {`	177	`if (TYPEOF(dimnames) == VECSXP) {`
178	`for (i = 0; i < n; i++) {`	178	`for (i = 0; i < n; i++) {`
179	`if (INTEGER(dims)[i] != 1) {`	179	`if (INTEGER(dims)[i] != 1) {`
180	`newnames = VECTOR(dimnames)[i];`	180	`newnames = VECTOR_ELT(dimnames, i);`
181	`break;`	181	`break;`
182	`}`	182	`}`
183	`}`	183	`}`
184	`}`	184	`}`
185	`else {`	185	`else {`
Line 208...	Line 208...
208	`if (INTEGER(dims)[i] != 1)`	208	`if (INTEGER(dims)[i] != 1)`
209	`INTEGER(newdims)[n++] = INTEGER(dims)[i];`	209	`INTEGER(newdims)[n++] = INTEGER(dims)[i];`
210	`if (!isNull(dimnames)) {`	210	`if (!isNull(dimnames)) {`
211	`int havenames = 0;`	211	`int havenames = 0;`
212	`for (i = 0; i < ndims; i++)`	212	`for (i = 0; i < ndims; i++)`
-		213	`if (INTEGER(dims)[i] != 1 &&`
213	`if (INTEGER(dims)[i] != 1 && VECTOR(dimnames)[i] != R_NilValue)`	214	`VECTOR_ELT(dimnames, i) != R_NilValue)`
214	`havenames = 1;`	215	`havenames = 1;`
215	`if (havenames) {`	216	`if (havenames) {`
216	`PROTECT(newnames = allocVector(VECSXP, n));`	217	`PROTECT(newnames = allocVector(VECSXP, n));`
217	`PROTECT(newnamesnames = allocVector(STRSXP, n));`	218	`PROTECT(newnamesnames = allocVector(STRSXP, n));`
218	`for (i = 0, n = 0; i < ndims; i++) {`	219	`for (i = 0, n = 0; i < ndims; i++) {`
219	`if (INTEGER(dims)[i] != 1) {`	220	`if (INTEGER(dims)[i] != 1) {`
220	`if(!isNull(dnn))`	221	`if(!isNull(dnn))`
221	`STRING(newnamesnames)[n] = STRING(dnn)[i];`	222	`SET_STRING_ELT(newnamesnames, n,`
-		223	`STRING_ELT(dnn, i));`
222	`VECTOR(newnames)[n++] = VECTOR(dimnames)[i];`	224	`SET_VECTOR_ELT(newnames, n++, VECTOR_ELT(dimnames, i));`
223	`}`	225	`}`
224	`}`	226	`}`
225	`}`	227	`}`
226	`else dimnames = R_NilValue;`	228	`else dimnames = R_NilValue;`
227	`}`	229	`}`
Line 519...	Line 521...
519		521
520	`if (isComplex(CAR(args)) \|\| isComplex(CADR(args)))`	522	`if (isComplex(CAR(args)) \|\| isComplex(CADR(args)))`
521	`mode = CPLXSXP;`	523	`mode = CPLXSXP;`
522	`else`	524	`else`
523	`mode = REALSXP;`	525	`mode = REALSXP;`
524	`CAR(args) = coerceVector(CAR(args), mode);`	526	`SETCAR(args, coerceVector(CAR(args), mode));`
525	`CADR(args) = coerceVector(CADR(args), mode);`	527	`SETCADR(args, coerceVector(CADR(args), mode));`
526		528
527	`if (PRIMVAL(op) == 0) {`	529	`if (PRIMVAL(op) == 0) {`
528	`PROTECT(ans = allocMatrix(mode, nrx, ncy));`	530	`PROTECT(ans = allocMatrix(mode, nrx, ncy));`
529	`if (mode == CPLXSXP)`	531	`if (mode == CPLXSXP)`
530	`cmatprod(COMPLEX(CAR(args)), nrx, ncx,`	532	`cmatprod(COMPLEX(CAR(args)), nrx, ncx,`
Line 539...	Line 541...
539	`PROTECT(dimnames = allocVector(VECSXP, 2));`	541	`PROTECT(dimnames = allocVector(VECSXP, 2));`
540	`PROTECT(dimnamesnames = allocVector(STRSXP, 2));`	542	`PROTECT(dimnamesnames = allocVector(STRSXP, 2));`
541	`if (xdims != R_NilValue) {`	543	`if (xdims != R_NilValue) {`
542	`if (ldx == 2 \|\| ncx ==1) {`	544	`if (ldx == 2 \|\| ncx ==1) {`
543	`dn = getAttrib(xdims, R_NamesSymbol);`	545	`dn = getAttrib(xdims, R_NamesSymbol);`
544	`VECTOR(dimnames)[0] = VECTOR(xdims)[0];`	546	`SET_VECTOR_ELT(dimnames, 0, VECTOR_ELT(xdims, 0));`
545	`if(!isNull(dn))`	547	`if(!isNull(dn))`
546	`STRING(dimnamesnames)[0] = STRING(dn)[0];`	548	`SET_STRING_ELT(dimnamesnames, 0, STRING_ELT(dn, 0));`
547	`}`	549	`}`
548	`}`	550	`}`
549	`if (ydims != R_NilValue) {`	551	`if (ydims != R_NilValue) {`
550	`if (ldy == 2 ){`	552	`if (ldy == 2 ){`
551	`dn = getAttrib(ydims, R_NamesSymbol);`	553	`dn = getAttrib(ydims, R_NamesSymbol);`
552	`VECTOR(dimnames)[1] = VECTOR(ydims)[1];`	554	`SET_VECTOR_ELT(dimnames, 1, VECTOR_ELT(ydims, 1));`
553	`if(!isNull(dn))`	555	`if(!isNull(dn))`
554	`STRING(dimnamesnames)[1] = STRING(dn)[1];`	556	`SET_STRING_ELT(dimnamesnames, 1, STRING_ELT(dn, 1));`
555	`} else if (nry == 1) {`	557	`} else if (nry == 1) {`
556	`dn = getAttrib(ydims, R_NamesSymbol);`	558	`dn = getAttrib(ydims, R_NamesSymbol);`
557	`VECTOR(dimnames)[1] = VECTOR(ydims)[0];`	559	`SET_VECTOR_ELT(dimnames, 1, VECTOR_ELT(ydims, 0));`
558	`if(!isNull(dn))`	560	`if(!isNull(dn))`
559	`STRING(dimnamesnames)[1] = STRING(dn)[0];`	561	`SET_STRING_ELT(dimnamesnames, 1, STRING_ELT(dn, 0));`
560	`}`	562	`}`
561	`}`	563	`}`
562	`setAttrib(dimnames, R_NamesSymbol, dimnamesnames);`	564	`setAttrib(dimnames, R_NamesSymbol, dimnamesnames);`
563	`setAttrib(ans, R_DimNamesSymbol, dimnames);`	565	`setAttrib(ans, R_DimNamesSymbol, dimnames);`
564	`UNPROTECT(2);`	566	`UNPROTECT(2);`
Line 578...	Line 580...
578	`SEXP dimnames, dimnamesnames, dnx=R_NilValue, dny=R_NilValue;`	580	`SEXP dimnames, dimnamesnames, dnx=R_NilValue, dny=R_NilValue;`
579	`PROTECT(dimnames = allocVector(VECSXP, 2));`	581	`PROTECT(dimnames = allocVector(VECSXP, 2));`
580	`PROTECT(dimnamesnames = allocVector(STRSXP, 2));`	582	`PROTECT(dimnamesnames = allocVector(STRSXP, 2));`
581	`if (xdims != R_NilValue) {`	583	`if (xdims != R_NilValue) {`
582	`dnx = getAttrib(xdims, R_NamesSymbol);`	584	`dnx = getAttrib(xdims, R_NamesSymbol);`
583	`VECTOR(dimnames)[0] = VECTOR(xdims)[1];`	585	`SET_VECTOR_ELT(dimnames, 0, VECTOR_ELT(xdims, 1));`
584	`if(!isNull(dnx))`	586	`if(!isNull(dnx))`
585	`STRING(dimnamesnames)[0] = STRING(dnx)[1];`	587	`SET_STRING_ELT(dimnamesnames, 0, STRING_ELT(dnx, 1));`
586	`}`	588	`}`
587	`if (ydims != R_NilValue) {`	589	`if (ydims != R_NilValue) {`
588	`dny = getAttrib(ydims, R_NamesSymbol);`	590	`dny = getAttrib(ydims, R_NamesSymbol);`
589	`VECTOR(dimnames)[1] = VECTOR(ydims)[1];`	591	`SET_VECTOR_ELT(dimnames, 1, VECTOR_ELT(ydims, 1));`
590	`if(!isNull(dny))`	592	`if(!isNull(dny))`
591	`STRING(dimnamesnames)[1] = STRING(dny)[1];`	593	`SET_STRING_ELT(dimnamesnames, 1, STRING_ELT(dny, 1));`
592	`}`	594	`}`
593	`if (!isNull(dnx) \|\| !isNull(dny))`	595	`if (!isNull(dnx) \|\| !isNull(dny))`
594	`setAttrib(dimnames, R_NamesSymbol, dimnamesnames);`	596	`setAttrib(dimnames, R_NamesSymbol, dimnamesnames);`
595	`setAttrib(ans, R_DimNamesSymbol, dimnames);`	597	`setAttrib(ans, R_DimNamesSymbol, dimnames);`
596	`UNPROTECT(2);`	598	`UNPROTECT(2);`
Line 622...	Line 624...
622	`case 1:`	624	`case 1:`
623	`nrow = len = length(a);`	625	`nrow = len = length(a);`
624	`ncol = 1;`	626	`ncol = 1;`
625	`rnames = getAttrib(a, R_DimNamesSymbol);`	627	`rnames = getAttrib(a, R_DimNamesSymbol);`
626	`if (rnames != R_NilValue)`	628	`if (rnames != R_NilValue)`
627	`rnames = VECTOR(rnames)[0];`	629	`rnames = VECTOR_ELT(rnames, 0);`
628	`break;`	630	`break;`
629	`case 2:`	631	`case 2:`
630	`ncol = ncols(a);`	632	`ncol = ncols(a);`
631	`nrow = nrows(a);`	633	`nrow = nrows(a);`
632	`len = length(a);`	634	`len = length(a);`
633	`dimnames = getAttrib(a, R_DimNamesSymbol);`	635	`dimnames = getAttrib(a, R_DimNamesSymbol);`
634	`if (dimnames != R_NilValue) {`	636	`if (dimnames != R_NilValue) {`
635	`rnames = VECTOR(dimnames)[0];`	637	`rnames = VECTOR_ELT(dimnames, 0);`
636	`cnames = VECTOR(dimnames)[1];`	638	`cnames = VECTOR_ELT(dimnames, 1);`
637	`dimnamesnames = getAttrib(dimnames, R_NamesSymbol);`	639	`dimnamesnames = getAttrib(dimnames, R_NamesSymbol);`
638	`}`	640	`}`
639	`break;`	641	`break;`
640	`default:`	642	`default:`
641	`goto not_matrix;`	643	`goto not_matrix;`
Line 658...	Line 660...
658	`for (i = 0; i < len; i++)`	660	`for (i = 0; i < len; i++)`
659	`COMPLEX(r)[i] = COMPLEX(a)[(i / ncol) + (i % ncol) * nrow];`	661	`COMPLEX(r)[i] = COMPLEX(a)[(i / ncol) + (i % ncol) * nrow];`
660	`break;`	662	`break;`
661	`case STRSXP:`	663	`case STRSXP:`
662	`for (i = 0; i < len; i++)`	664	`for (i = 0; i < len; i++)`
-		665	`SET_STRING_ELT(r, i,`
663	`STRING(r)[i] = STRING(a)[(i / ncol) + (i % ncol) * nrow];`	666	`STRING_ELT(a, (i / ncol) + (i % ncol) * nrow));`
664	`break;`	667	`break;`
665	`case VECSXP:`	668	`case VECSXP:`
666	`for (i = 0; i < len; i++)`	669	`for (i = 0; i < len; i++)`
-		670	`SET_VECTOR_ELT(r, i,`
667	`VECTOR(r)[i] = VECTOR(a)[(i / ncol) + (i % ncol) * nrow];`	671	`VECTOR_ELT(a, (i / ncol) + (i % ncol) * nrow));`
668	`break;`	672	`break;`
669	`default:`	673	`default:`
670	`goto not_matrix;`	674	`goto not_matrix;`
671	`}`	675	`}`
672	`PROTECT(dims = allocVector(INTSXP, 2));`	676	`PROTECT(dims = allocVector(INTSXP, 2));`
Line 674...	Line 678...
674	`INTEGER(dims)[1] = nrow;`	678	`INTEGER(dims)[1] = nrow;`
675	`setAttrib(r, R_DimSymbol, dims);`	679	`setAttrib(r, R_DimSymbol, dims);`
676	`UNPROTECT(1);`	680	`UNPROTECT(1);`
677	`if(rnames != R_NilValue \|\| cnames != R_NilValue) {`	681	`if(rnames != R_NilValue \|\| cnames != R_NilValue) {`
678	`PROTECT(dimnames = allocVector(VECSXP, 2));`	682	`PROTECT(dimnames = allocVector(VECSXP, 2));`
679	`VECTOR(dimnames)[0] = cnames;`	683	`SET_VECTOR_ELT(dimnames, 0, cnames);`
680	`VECTOR(dimnames)[1] = rnames;`	684	`SET_VECTOR_ELT(dimnames, 1, rnames);`
681	`if(!isNull(dimnamesnames)) {`	685	`if(!isNull(dimnamesnames)) {`
682	`PROTECT(ndimnamesnames = allocVector(VECSXP, 2));`	686	`PROTECT(ndimnamesnames = allocVector(VECSXP, 2));`
683	`STRING(ndimnamesnames)[1] = STRING(dimnamesnames)[0];`	687	`SET_STRING_ELT(ndimnamesnames, 1, STRING_ELT(dimnamesnames, 0));`
684	`STRING(ndimnamesnames)[0] = STRING(dimnamesnames)[1];`	688	`SET_STRING_ELT(ndimnamesnames, 0, STRING_ELT(dimnamesnames, 1));`
685	`setAttrib(dimnames, R_NamesSymbol, ndimnamesnames);`	689	`setAttrib(dimnames, R_NamesSymbol, ndimnamesnames);`
686	`UNPROTECT(1);`	690	`UNPROTECT(1);`
687	`}`	691	`}`
688	`setAttrib(r, R_DimNamesSymbol, dimnames);`	692	`setAttrib(r, R_DimNamesSymbol, dimnames);`
689	`UNPROTECT(1);`	693	`UNPROTECT(1);`
Line 773...	Line 777...
773	`}`	777	`}`
774	`break;`	778	`break;`
775	`case STRSXP:`	779	`case STRSXP:`
776	`for (i = 0; i < len; i++) {`	780	`for (i = 0; i < len; i++) {`
777	`j = swap(i, dimsa, dimsr, perm, ind1, ind2);`	781	`j = swap(i, dimsa, dimsr, perm, ind1, ind2);`
778	`STRING(r)[j] = STRING(a)[i];`	782	`SET_STRING_ELT(r, j, STRING_ELT(a, i));`
779	`}`	783	`}`
780	`break;`	784	`break;`
781	`case VECSXP:`	785	`case VECSXP:`
782	`for (i = 0; i < len; i++) {`	786	`for (i = 0; i < len; i++) {`
783	`j = swap(i, dimsa, dimsr, perm, ind1, ind2);`	787	`j = swap(i, dimsa, dimsr, perm, ind1, ind2);`
784	`VECTOR(r)[j] = VECTOR(a)[i];`	788	`SET_VECTOR_ELT(r, j, VECTOR_ELT(a, i));`
785	`}`	789	`}`
786	`default:`	790	`default:`
787	`errorcall(call, R_MSG_IA);`	791	`errorcall(call, R_MSG_IA);`
788	`}`	792	`}`
789		793

The R Project SVN R

(root)/branches/R-GenGC/src/main/array.c – Rev 9615 → 9642