--- Matrix/src/Mutils.c.orig	Mon Nov  2 12:55:36 2009
+++ Matrix/src/Mutils.c	Tue Dec 29 05:27:24 2009
@@ -7,39 +7,25 @@
        * La_norm_type() & La_rcond_type() are now in R_ext/Lapack.h
        * but because of the 'module-mess' that's not sufficient */
 #else
-char La_norm_type(const char *typstr)
+char La_norm_type(const char typstr)
 {
-    char typup;
-
-    if (strlen(typstr) != 1)
-	error(
-	    _("argument type[1]='%s' must be a one-letter character string"),
-	    typstr);
-    typup = toupper(*typstr);
+    char typup = toupper(typstr);
     if (typup == '1')
 	typup = 'O'; /* alias */
     else if (typup == 'E')
 	typup = 'F';
     else if (typup != 'M' && typup != 'O' && typup != 'I' && typup != 'F')
-	error(_("argument type[1]='%s' must be one of 'M','1','O','I','F' or 'E'"),
-	      typstr);
+	error(_("argument '%c' must be one of 'M','1','O','I','F' or 'E'"), typstr);
     return typup;
 }
 
-char La_rcond_type(const char *typstr)
+char La_rcond_type(const char typstr)
 {
-    char typup;
-
-    if (strlen(typstr) != 1)
-	error(
-	    _("argument type[1]='%s' must be a one-letter character string"),
-	    typstr);
-    typup = toupper(*typstr);
+    char typup = toupper(typstr);
     if (typup == '1')
 	typup = 'O'; /* alias */
     else if (typup != 'O' && typup != 'I')
-	error(_("argument type[1]='%s' must be one of '1','O', or 'I'"),
-	      typstr);
+	error(_("argument '%c' must be one of '1','O', or 'I'"), typstr);
     return typup;
 }
 #endif
--- Matrix/src/Mutils.h.orig	Fri Dec 11 13:54:49 2009
+++ Matrix/src/Mutils.h	Tue Dec 29 05:26:13 2009
@@ -54,8 +54,8 @@
 #define RGT CblasRight
 
 #if !defined(R_VERSION) || R_VERSION < R_Version(2, 7, 0)
-char La_norm_type(const char *typstr);
-char La_rcond_type(const char *typstr);
+char La_norm_type(const char typstr);
+char La_rcond_type(const char typstr);
 #endif
 
 double get_double_by_name(SEXP obj, char *nm);
--- Matrix/src/dense.c.orig	Thu Mar 12 11:40:52 2009
+++ Matrix/src/dense.c	Tue Dec 29 06:02:39 2009
@@ -41,7 +41,7 @@
 	double tmp = x[diagind], cc, ss;
 				/* Calculate the Givens rotation. */
 				/* This modified the super-diagonal element */
-	F77_CALL(drotg)(x + diagind-1, &tmp, cosines + ind, sines + ind);
+	SPL_CALL(drotg)(x + diagind-1, &tmp, cosines + ind, sines + ind);
 	cc = cosines[ind]; ss = sines[ind];
 				/* Copy column jj+1 to column jj. */
 	for(i = 0; i < jj; i++) x[i + (jj-1)*ldx] = x[i+jj*ldx];
@@ -117,12 +117,11 @@
     k = ydims[1];
     if (k < 1 || p < 1) return allocMatrix(REALSXP, p, k);
     ans = PROTECT(allocMatrix(REALSXP, p, k));
-    F77_CALL(dgemm)("T", "N", &p, &k, &n, &d_one, REAL(X), &n, REAL(y), &n,
-		    &d_zero, REAL(ans), &p);
+    SPL_CALL(dgemm)('T', 'N', p, k, n, d_one, REAL(X), n, REAL(y), n,
+		    d_zero, REAL(ans), p);
     xpx = (double *) R_alloc(p * p, sizeof(double));
-    F77_CALL(dsyrk)("U", "T", &p, &n, &d_one, REAL(X), &n, &d_zero,
-		    xpx, &p);
-    F77_CALL(dposv)("U", &p, &k, xpx, &p, REAL(ans), &p, &info);
+    SPL_CALL(dsyrk)('U', 'T', p, n, d_one, REAL(X), n, d_zero, xpx, p);
+    SPL_CALL(dposv)('U', p, k, xpx, p, REAL(ans), p, &info);
     if (info) error(_("Lapack routine dposv returned error code %d"), info);
     UNPROTECT(1);
     return ans;
@@ -132,8 +131,8 @@
 SEXP lsq_dense_QR(SEXP X, SEXP y)
 {
     SEXP ans;
-    int info, n, p, k, *Xdims, *ydims, lwork;
-    double *work, tmp, *xvals;
+    int info, n, p, k, *Xdims, *ydims;
+    double *xvals;
 
     if (!(isReal(X) & isMatrix(X)))
 	error(_("X must be a numeric (double precision) matrix"));
@@ -152,17 +151,8 @@
     xvals = (double *) R_alloc(n * p, sizeof(double));
     Memcpy(xvals, REAL(X), n * p);
     ans = PROTECT(duplicate(y));
-    lwork = -1;
-    F77_CALL(dgels)("N", &n, &p, &k, xvals, &n, REAL(ans), &n,
-		    &tmp, &lwork, &info);
+    SPL_CALL(dgels)('N', n, p, k, xvals, n, REAL(ans), n, &info);
     if (info)
-	error(_("First call to Lapack routine dgels returned error code %d"),
-	      info);
-    lwork = (int) tmp;
-    work = (double *) R_alloc(lwork, sizeof(double));
-    F77_CALL(dgels)("N", &n, &p, &k, xvals, &n, REAL(ans), &n,
-		    work, &lwork, &info);
-    if (info)
 	error(_("Second call to Lapack routine dgels returned error code %d"),
 	      info);
     UNPROTECT(1);
@@ -173,7 +163,7 @@
 {
     SEXP ans, Givens, Gcpy, nms, pivot, qraux, X;
     int i, n, nGivens = 0, p, trsz, *Xdims, rank;
-    double rcond = 0., tol = asReal(tl), *work;
+    double rcond = 0., tol = asReal(tl);
 
     if (!(isReal(Xin) & isMatrix(Xin)))
 	error(_("X must be a real (numeric) matrix"));
@@ -196,22 +186,13 @@
     SET_STRING_ELT(nms, 3, mkChar("pivot"));
     SET_STRING_ELT(nms, 4, mkChar("Givens"));
     if (n > 0 && p > 0) {
-	int  info, *iwork, lwork;
-	double *xpt = REAL(X), tmp;
+	int  info;
+	double *xpt = REAL(X);
 
-	lwork = -1;
-	F77_CALL(dgeqrf)(&n, &p, xpt, &n, REAL(qraux), &tmp, &lwork, &info);
+	SPL_CALL(dgeqrf)(n, p, xpt, n, REAL(qraux), &info);
 	if (info)
-	    error(_("First call to dgeqrf returned error code %d"), info);
-	lwork = (int) tmp;
-	work = (double *) R_alloc((lwork < 3*trsz) ? 3*trsz : lwork,
-				  sizeof(double));
-	F77_CALL(dgeqrf)(&n, &p, xpt, &n, REAL(qraux), work, &lwork, &info);
-	if (info)
 	    error(_("Second call to dgeqrf returned error code %d"), info);
-	iwork = (int *) R_alloc(trsz, sizeof(int));
-	F77_CALL(dtrcon)("1", "U", "N", &rank, xpt, &n, &rcond,
-			 work, iwork, &info);
+	SPL_CALL(dtrcon)('1', 'U', 'N', rank, xpt, n, &rcond, &info);
 	if (info)
 	    error(_("Lapack routine dtrcon returned error code %d"), info);
 	while (rcond < tol) {	/* check diagonal elements */
@@ -230,8 +211,7 @@
 		nGivens++;
 	    }
 	    rank--;
-	    F77_CALL(dtrcon)("1", "U", "N", &rank, xpt, &n, &rcond,
-			     work, iwork, &info);
+	    SPL_CALL(dtrcon)('1', 'U', 'N', rank, xpt, n, &rcond, &info);
 	    if (info)
 		error(_("Lapack routine dtrcon returned error code %d"), info);
 	}
--- Matrix/src/dgeMatrix.c.orig	Sat Oct 24 22:40:09 2009
+++ Matrix/src/dgeMatrix.c	Tue Dec 29 06:04:35 2009
@@ -37,20 +37,19 @@
 }
 
 static
-double get_norm(SEXP obj, const char *typstr)
+double get_norm(SEXP obj, const char typstr)
 {
     if(any_NA_in_x(obj))
 	return NA_REAL;
     else {
-	char typnm[] = {'\0', '\0'};
 	int *dims = INTEGER(GET_SLOT(obj, Matrix_DimSym));
 	double *work = (double *) NULL;
 
-	typnm[0] = La_norm_type(typstr);
-	if (*typnm == 'I') {
+	char typnm = La_norm_type(typstr);
+	if (typnm == 'I') {
 	    work = (double *) R_alloc(dims[0], sizeof(double));
 	}
-	return F77_CALL(dlange)(typstr, dims, dims+1,
+	return F77_CALL(dlange)(&typstr, dims, dims+1,
 				REAL(GET_SLOT(obj, Matrix_xSym)),
 				dims, work);
     }
@@ -58,27 +57,23 @@
 
 SEXP dgeMatrix_norm(SEXP obj, SEXP type)
 {
-    return ScalarReal(get_norm(obj, CHAR(asChar(type))));
+    return ScalarReal(get_norm(obj, *CHAR(asChar(type))));
 }
 
 SEXP dgeMatrix_rcond(SEXP obj, SEXP type)
 {
     SEXP LU = PROTECT(dgeMatrix_LU_(obj, FALSE));/* <- not warning about singularity */
-    char typnm[] = {'\0', '\0'};
     int *dims = INTEGER(GET_SLOT(LU, Matrix_DimSym)), info;
     double anorm, rcond;
+    char typnm = La_rcond_type(*CHAR(asChar(type)));
 
     if (dims[0] != dims[1] || dims[0] < 1) {
 	UNPROTECT(1);
 	error(_("rcond requires a square, non-empty matrix"));
     }
-    typnm[0] = La_rcond_type(CHAR(asChar(type)));
     anorm = get_norm(obj, typnm);
-    F77_CALL(dgecon)(typnm,
-		     dims, REAL(GET_SLOT(LU, Matrix_xSym)),
-		     dims, &anorm, &rcond,
-		     (double *) R_alloc(4*dims[0], sizeof(double)),
-		     (int *) R_alloc(dims[0], sizeof(int)), &info);
+    SPL_CALL(dgecon)(typnm, *dims, REAL(GET_SLOT(LU, Matrix_xSym)),
+		     *dims, anorm, &rcond, &info);
     UNPROTECT(1);
     return ScalarReal(rcond);
 }
@@ -102,9 +97,9 @@
     SET_VECTOR_ELT(vDnms, 0, duplicate(nms));
     SET_VECTOR_ELT(vDnms, 1, duplicate(nms));
     if(n)
-    F77_CALL(dsyrk)("U", tr ? "N" : "T", &n, &k,
-		    &one, REAL(GET_SLOT(x, Matrix_xSym)), Dims,
-		    &zero, vx, &n);
+    SPL_CALL(dsyrk)('U', tr ? 'N' : 'T', n, k,
+		    one, REAL(GET_SLOT(x, Matrix_xSym)), *Dims,
+		    zero, vx, n);
     SET_SLOT(val, Matrix_factorSym, allocVector(VECSXP, 0));
     UNPROTECT(1);
     return val;
@@ -130,10 +125,10 @@
 		  tr ? "tcrossprod" : "crossprod");
 	vDims[0] = m; vDims[1] = n;
 	SET_SLOT(val, Matrix_xSym, allocVector(REALSXP, m * n));
-	F77_CALL(dgemm)(tr ? "N" : "T", tr ? "T" : "N", &m, &n, &xd, &one,
-			REAL(GET_SLOT(x, Matrix_xSym)), xDims,
-			REAL(GET_SLOT(y, Matrix_xSym)), yDims,
-			&zero, REAL(GET_SLOT(val, Matrix_xSym)), &m);
+	SPL_CALL(dgemm)(tr ? 'N' : 'T', tr ? 'T' : 'N', m, n, xd, one,
+			REAL(GET_SLOT(x, Matrix_xSym)), *xDims,
+			REAL(GET_SLOT(y, Matrix_xSym)), *yDims,
+			zero, REAL(GET_SLOT(val, Matrix_xSym)), m);
     }
     UNPROTECT(1);
     return val;
@@ -165,10 +160,10 @@
 		  tr ? "tcrossprod" : "crossprod");
 	vDims[0] = m; vDims[1] = n;
 	SET_SLOT(val, Matrix_xSym, allocVector(REALSXP, m * n));
-	F77_CALL(dgemm)(tr ? "N" : "T", tr ? "T" : "N", &m, &n, &xd, &one,
-			REAL(GET_SLOT(x, Matrix_xSym)), xDims,
-			REAL(y), yDims,
-			&zero, REAL(GET_SLOT(val, Matrix_xSym)), &m);
+	SPL_CALL(dgemm)(tr ? 'N' : 'T', tr ? 'T' : 'N', m, n, xd, one,
+			REAL(GET_SLOT(x, Matrix_xSym)), *xDims,
+			REAL(y), *yDims,
+			zero, REAL(GET_SLOT(val, Matrix_xSym)), m);
     }
     UNPROTECT(nprot);
     return val;
@@ -226,8 +221,8 @@
     val = PROTECT(NEW_OBJECT(MAKE_CLASS("denseLU")));
     slot_dup(val, x, Matrix_xSym);
     slot_dup(val, x, Matrix_DimSym);
-    F77_CALL(dgetrf)(dims, dims + 1, REAL(GET_SLOT(val, Matrix_xSym)),
-		     dims,
+    SPL_CALL(dgetrf)(*dims, dims[1], REAL(GET_SLOT(val, Matrix_xSym)),
+		     *dims,
 		     INTEGER(ALLOC_SLOT(val, Matrix_permSym, INTSXP, npiv)),
 		     &info);
     if (info < 0)
@@ -282,20 +277,15 @@
 	lu = dgeMatrix_LU_(a, TRUE);
     int *dims = INTEGER(GET_SLOT(lu, Matrix_DimSym)),
 	*pivot = INTEGER(GET_SLOT(lu, Matrix_permSym));
-    double *x, tmp;
-    int	info, lwork = -1;
+    double *x;
+    int	info;
 
-
     if (dims[0] != dims[1]) error(_("Solve requires a square matrix"));
     slot_dup(val, lu, Matrix_xSym);
     x = REAL(GET_SLOT(val, Matrix_xSym));
     slot_dup(val, lu, Matrix_DimSym);
     if(dims[0]) {
-	F77_CALL(dgetri)(dims, x, dims, pivot, &tmp, &lwork, &info);
-	lwork = (int) tmp;
-	F77_CALL(dgetri)(dims, x, dims, pivot,
-			 (double *) R_alloc((size_t) lwork, sizeof(double)),
-			 &lwork, &info);
+	SPL_CALL(dgetri)(*dims, x, *dims, pivot, &info);
 	if (info)
 	    error(_("Lapack routine dgetri: system is exactly singular"));
     }
@@ -313,9 +303,9 @@
 
     if (*adims != *bdims || bdims[1] < 1 || *adims < 1 || *adims != adims[1])
 	error(_("Dimensions of system to be solved are inconsistent"));
-    F77_CALL(dgetrs)("N", &n, &nrhs, REAL(GET_SLOT(lu, Matrix_xSym)), &n,
+    SPL_CALL(dgetrs)('N', n, nrhs, REAL(GET_SLOT(lu, Matrix_xSym)), n,
 		     INTEGER(GET_SLOT(lu, Matrix_permSym)),
-		     REAL(GET_SLOT(val, Matrix_xSym)), &n, &info);
+		     REAL(GET_SLOT(val, Matrix_xSym)), n, &info);
     if (info)
 	error(_("Lapack routine dgetrs: system is exactly singular"));
     UNPROTECT(2);
@@ -340,11 +330,10 @@
 /* 	    error(_("Matrices with zero extents cannot be multiplied")); */
 	    ALLOC_SLOT(val, Matrix_xSym, REALSXP, m * n);
 	} else
-	    F77_CALL(dgemm) ("N", "N", &m, &n, &k, &one,
-			     REAL(GET_SLOT(b, Matrix_xSym)), &m,
-			     REAL(GET_SLOT(a, Matrix_xSym)), &k, &zero,
-			     REAL(ALLOC_SLOT(val, Matrix_xSym, REALSXP, m * n)),
-			     &m);
+	    SPL_CALL(dgemm) ('N', 'N', m, n, k, one,
+			     REAL(GET_SLOT(b, Matrix_xSym)), m,
+			     REAL(GET_SLOT(a, Matrix_xSym)), k, zero,
+			     REAL(ALLOC_SLOT(val, Matrix_xSym, REALSXP, m * n)), m);
     } else {
 	int m = adims[0], n = bdims[1], k = adims[1];
 
@@ -355,10 +344,10 @@
 /* 	    error(_("Matrices with zero extents cannot be multiplied")); */
 	    ALLOC_SLOT(val, Matrix_xSym, REALSXP, m * n);
 	} else
-	    F77_CALL(dgemm)
-		("N", "N", &m, &n, &k, &one, REAL(GET_SLOT(a, Matrix_xSym)),
-		 &m, REAL(GET_SLOT(b, Matrix_xSym)), &k, &zero,
-		 REAL(ALLOC_SLOT(val, Matrix_xSym, REALSXP, m * n)), &m);
+	    SPL_CALL(dgemm)
+		('N', 'N', m, n, k, one, REAL(GET_SLOT(a, Matrix_xSym)),
+		 m, REAL(GET_SLOT(b, Matrix_xSym)), k, zero,
+		 REAL(ALLOC_SLOT(val, Matrix_xSym, REALSXP, m * n)), m);
     }
     ALLOC_SLOT(val, Matrix_DimNamesSym, VECSXP, 2);
     UNPROTECT(2);
@@ -375,29 +364,15 @@
     SEXP val = PROTECT(allocVector(VECSXP, 3));
 
     if (dims[0] && dims[1]) {
-	int m = dims[0], n = dims[1], mm = (m < n)?m:n,
-	    lwork = -1, info;
-	double tmp, *work;
-	int *iwork = Alloca(8 * mm, int);
-	R_CheckStack();
+	int m = dims[0], n = dims[1], mm = (m < n) ? m : n, info;
 
 	SET_VECTOR_ELT(val, 0, allocVector(REALSXP, mm));
 	SET_VECTOR_ELT(val, 1, allocMatrix(REALSXP, m, mm));
 	SET_VECTOR_ELT(val, 2, allocMatrix(REALSXP, mm, n));
-	F77_CALL(dgesdd)("S", &m, &n, xx, &m,
+	SPL_CALL(dgesdd)('S', m, n, xx, m,
 			 REAL(VECTOR_ELT(val, 0)),
-			 REAL(VECTOR_ELT(val, 1)), &m,
-			 REAL(VECTOR_ELT(val, 2)), &mm,
-			 &tmp, &lwork, iwork, &info);
-	lwork = (int) tmp;
-	work = Alloca(lwork, double);
-	R_CheckStack();
-	F77_CALL(dgesdd)("S", &m, &n, xx, &m,
-			 REAL(VECTOR_ELT(val, 0)),
-			 REAL(VECTOR_ELT(val, 1)), &m,
-			 REAL(VECTOR_ELT(val, 2)), &mm,
-			 work, &lwork, iwork, &info);
-
+			 REAL(VECTOR_ELT(val, 1)), m,
+			 REAL(VECTOR_ELT(val, 2)), mm, &info);
     }
     UNPROTECT(1);
     return val;
@@ -457,9 +432,9 @@
     }
 
     /* Preconditioning 2. Balancing with dgebal. */
-    F77_CALL(dgebal)("P", &n, v, &n, &ilo, &ihi, perm, &j);
+    SPL_CALL(dgebal)('P', n, v, n, &ilo, &ihi, perm, &j);
     if (j) error(_("dgeMatrix_exp: LAPACK routine dgebal returned %d"), j);
-    F77_CALL(dgebal)("S", &n, v, &n, &ilos, &ihis, scale, &j);
+    SPL_CALL(dgebal)('S', n, v, n, &ilos, &ihis, scale, &j);
     if (j) error(_("dgeMatrix_exp: LAPACK routine dgebal returned %d"), j);
 
     /* Preconditioning 3. Scaling according to infinity norm */
@@ -479,13 +454,13 @@
     for (j = 7; j >=0; j--) {
 	double mult = padec[j];
 	/* npp = m * npp + padec[j] *m */
-	F77_CALL(dgemm)("N", "N", &n, &n, &n, &one, v, &n, npp, &n,
-			&zero, work, &n);
+	SPL_CALL(dgemm)('N', 'N', n, n, n, one, v, n, npp, n,
+			zero, work, n);
 	for (i = 0; i < nsqr; i++) npp[i] = work[i] + mult * v[i];
 	/* dpp = m * dpp + (m1_j * padec[j]) * m */
 	mult *= m1_j;
-	F77_CALL(dgemm)("N", "N", &n, &n, &n, &one, v, &n, dpp, &n,
-			&zero, work, &n);
+	SPL_CALL(dgemm)('N', 'N', n, n, n, one, v, n, dpp, n,
+			zero, work, n);
 	for (i = 0; i < nsqr; i++) dpp[i] = work[i] + mult * v[i];
 	m1_j *= -1;
     }
@@ -497,9 +472,9 @@
     }
 
     /* Pade' approximation is solve(dpp, npp) */
-    F77_CALL(dgetrf)(&n, &n, dpp, &n, pivot, &j);
+    SPL_CALL(dgetrf)(n, n, dpp, n, pivot, &j);
     if (j) error(_("dgeMatrix_exp: dgetrf returned error code %d"), j);
-    F77_CALL(dgetrs)("N", &n, &n, dpp, &n, pivot, npp, &n, &j);
+    SPL_CALL(dgetrs)('N', n, n, dpp, n, pivot, npp, n, &j);
     if (j) error(_("dgeMatrix_exp: dgetrs returned error code %d"), j);
     Memcpy(v, npp, nsqr);
 
@@ -506,8 +481,7 @@
     /* Now undo all of the preconditioning */
     /* Preconditioning 3: square the result for every power of 2 */
     while (sqpow--) {
-	F77_CALL(dgemm)("N", "N", &n, &n, &n, &one, v, &n, v, &n,
-			&zero, work, &n);
+	SPL_CALL(dgemm)('N', 'N', n, n, n, one, v, n, v, n, zero, work, n);
 	Memcpy(v, work, nsqr);
     }
     /* Preconditioning 2: apply inverse scaling */
@@ -520,9 +494,9 @@
     if (ilo != 1 || ihi != n) {
 	/* Martin Maechler's code */
 
-#define SWAP_ROW(I,J) F77_CALL(dswap)(&n, &v[(I)], &n, &v[(J)], &n)
+#define SWAP_ROW(I,J) SPL_CALL(dswap)(n, &v[(I)], n, &v[(J)], n)
 
-#define SWAP_COL(I,J) F77_CALL(dswap)(&n, &v[(I)*n], &i1, &v[(J)*n], &i1)
+#define SWAP_COL(I,J) SPL_CALL(dswap)(n, &v[(I)*n], i1, &v[(J)*n], i1)
 
 #define RE_PERMUTE(I)				\
 	int p_I = (int) (perm[I]) - 1;		\
@@ -555,8 +529,7 @@
 SEXP dgeMatrix_Schur(SEXP x, SEXP vectors)
 {
     int *dims = INTEGER(GET_SLOT(x, Matrix_DimSym));
-    int vecs = asLogical(vectors), info, izero = 0, lwork = -1, n = dims[0];
-    double *work, tmp;
+    int vecs = asLogical(vectors), info, izero = 0, n = dims[0];
     const char *nms[] = {"WR", "WI", "T", "Z", ""};
     SEXP val = PROTECT(Matrix_make_named(VECSXP, nms));
 
@@ -567,17 +540,9 @@
     SET_VECTOR_ELT(val, 2, allocMatrix(REALSXP, n, n));
     Memcpy(REAL(VECTOR_ELT(val, 2)), REAL(GET_SLOT(x, Matrix_xSym)), n * n);
     SET_VECTOR_ELT(val, 3, allocMatrix(REALSXP, vecs ? n : 0, vecs ? n : 0));
-    F77_CALL(dgees)(vecs ? "V" : "N", "N", NULL, dims, (double *) NULL, dims, &izero,
-		    (double *) NULL, (double *) NULL, (double *) NULL, dims,
-		    &tmp, &lwork, (int *) NULL, &info);
-    if (info) error(_("dgeMatrix_Schur: first call to dgees failed"));
-    lwork = (int) tmp;
-    work = Alloca(lwork, double);
-    R_CheckStack();
-    F77_CALL(dgees)(vecs ? "V" : "N", "N", NULL, dims, REAL(VECTOR_ELT(val, 2)), dims,
+    SPL_CALL(dgees)(vecs ? 'V' : 'N', 'N', NULL, *dims, REAL(VECTOR_ELT(val, 2)), *dims,
 		    &izero, REAL(VECTOR_ELT(val, 0)), REAL(VECTOR_ELT(val, 1)),
-		    REAL(VECTOR_ELT(val, 3)), dims, work, &lwork,
-		    (int *) NULL, &info);
+		    REAL(VECTOR_ELT(val, 3)), *dims, &info);
     if (info) error(_("dgeMatrix_Schur: dgees returned code %d"), info);
     UNPROTECT(1);
     return val;
--- Matrix/src/dgeMatrix.h.orig	Wed Mar 11 19:41:28 2009
+++ Matrix/src/dgeMatrix.h	Tue Dec 29 05:33:41 2009
@@ -28,16 +28,4 @@
 SEXP dgeMatrix_exp(SEXP x);
 SEXP dgeMatrix_colsums(SEXP x, SEXP naRmP, SEXP cols, SEXP mean);
 
-/* DGESDD - compute the singular value decomposition (SVD); of a   */
-/* real M-by-N matrix A, optionally computing the left and/or      */
-/* right singular vectors.  If singular vectors are desired, it uses a */
-/* divide-and-conquer algorithm.                                   */
-void F77_NAME(dgesdd)(const char *jobz,
-		      const int *m, const int *n,
-		      double *a, const int *lda, double *s,
-		      double *u, const int *ldu,
-		      double *vt, const int *ldvt,
-		      double *work, const int *lwork, int *iwork, int *info);
-
-
 #endif
--- Matrix/src/dpoMatrix.c.orig	Wed Aug  1 17:22:05 2007
+++ Matrix/src/dpoMatrix.c	Tue Dec 29 04:54:32 2009
@@ -33,7 +33,7 @@
     AZERO(vx, n * n);
     F77_CALL(dlacpy)(uplo, &n, &n, REAL(GET_SLOT(x, Matrix_xSym)), &n, vx, &n);
     if (n > 0) {
-	F77_CALL(dpotrf)(uplo, &n, vx, &n, &info);
+	SPL_CALL(dpotrf)(*uplo, n, vx, n, &info);
 	if (info) {
 	    if(info > 0)
 		error(_("the leading minor of order %d is not positive definite"),
@@ -49,15 +49,12 @@
 SEXP dpoMatrix_rcond(SEXP obj, SEXP type)
 {
     SEXP Chol = dpoMatrix_chol(obj);
-    const char typnm[] = {'O', '\0'};	/* always use the one norm */
     int *dims = INTEGER(GET_SLOT(Chol, Matrix_DimSym)), info;
-    double anorm = get_norm_sy(obj, typnm), rcond;
+    double anorm = get_norm_sy(obj, '0'), rcond; /* always use the one norm */
 
-    F77_CALL(dpocon)(uplo_P(Chol),
-		     dims, REAL(GET_SLOT(Chol, Matrix_xSym)),
-		     dims, &anorm, &rcond,
-		     (double *) R_alloc(3*dims[0], sizeof(double)),
-		     (int *) R_alloc(dims[0], sizeof(int)), &info);
+    SPL_CALL(dpocon)(*uplo_P(Chol),
+		     *dims, REAL(GET_SLOT(Chol, Matrix_xSym)),
+		     *dims, anorm, &rcond, &info);
     return ScalarReal(rcond);
 }
 
@@ -73,8 +70,8 @@
     slot_dup(val, Chol, Matrix_DimSym);
     SET_SLOT(val, Matrix_DimNamesSym,
 	     duplicate(GET_SLOT(x, Matrix_DimNamesSym)));
-    F77_CALL(dpotri)(uplo_P(val), dims,
-		     REAL(GET_SLOT(val, Matrix_xSym)), dims, &info);
+    SPL_CALL(dpotri)(*uplo_P(val), *dims,
+		     REAL(GET_SLOT(val, Matrix_xSym)), *dims, &info);
     UNPROTECT(1);
     return val;
 }
@@ -94,10 +91,10 @@
     SET_SLOT(val, Matrix_factorSym, allocVector(VECSXP, 0));
     slot_dup(val, b, Matrix_DimSym);
     slot_dup(val, b, Matrix_xSym);
-    F77_CALL(dpotrs)(uplo_P(Chol), adims, bdims + 1,
-		     REAL(GET_SLOT(Chol, Matrix_xSym)), adims,
+    SPL_CALL(dpotrs)(*uplo_P(Chol), *adims, bdims[1],
+		     REAL(GET_SLOT(Chol, Matrix_xSym)), *adims,
 		     REAL(GET_SLOT(val, Matrix_xSym)),
-		     bdims, &info);
+		     *bdims, &info);
     UNPROTECT(1);
     return val;
 }
@@ -114,9 +111,9 @@
 	error(_("Argument b must be a numeric matrix"));
     if (*adims != *bdims || bdims[1] < 1 || *adims < 1)
 	error(_("Dimensions of system to be solved are inconsistent"));
-    F77_CALL(dpotrs)(uplo_P(Chol), adims, bdims + 1,
-		     REAL(GET_SLOT(Chol, Matrix_xSym)), adims,
-		     REAL(val), bdims, &info);
+    SPL_CALL(dpotrs)(*uplo_P(Chol), *adims, bdims[1],
+		     REAL(GET_SLOT(Chol, Matrix_xSym)), *adims,
+		     REAL(val), *bdims, &info);
     UNPROTECT(1);
     return val;
 }
--- Matrix/src/dpoMatrix.h.orig	Mon Jun  4 19:13:02 2007
+++ Matrix/src/dpoMatrix.h	Tue Dec 29 04:21:55 2009
@@ -10,6 +10,6 @@
 SEXP dpoMatrix_matrix_solve(SEXP a, SEXP b);
 SEXP dpoMatrix_dgeMatrix_solve(SEXP a, SEXP b);
 SEXP dpoMatrix_chol(SEXP x);
-double get_norm_sy(SEXP obj, const char *typstr);
+double get_norm_sy(SEXP obj, const char typstr);
 
 #endif
--- Matrix/src/dppMatrix.c.orig	Sun Jul  8 00:49:12 2007
+++ Matrix/src/dppMatrix.c	Tue Dec 29 04:56:16 2009
@@ -27,7 +27,7 @@
     SET_SLOT(val, Matrix_diagSym, mkString("N"));
     SET_SLOT(val, Matrix_DimSym, duplicate(dimP));
     slot_dup(val, x, Matrix_xSym);
-    F77_CALL(dpptrf)(uplo, dims, REAL(GET_SLOT(val, Matrix_xSym)), &info);
+    SPL_CALL(dpptrf)(*uplo, *dims, REAL(GET_SLOT(val, Matrix_xSym)), &info);
     if (info) {
 	if(info > 0) /* e.g. x singular */
 	    error(_("the leading minor of order %d is not positive definite"),
@@ -42,14 +42,11 @@
 SEXP dppMatrix_rcond(SEXP obj, SEXP type)
 {
     SEXP Chol = dppMatrix_chol(obj);
-    char typnm[] = {'O', '\0'};	/* always use the one norm */
     int *dims = INTEGER(GET_SLOT(Chol, Matrix_DimSym)), info;
-    double anorm = get_norm_sp(obj, typnm), rcond;
+    double anorm = get_norm_sp(obj, '0'), rcond; /* always use the one norm */
 
-    F77_CALL(dppcon)(uplo_P(Chol), dims,
-		     REAL(GET_SLOT(Chol, Matrix_xSym)), &anorm, &rcond,
-		     (double *) R_alloc(3*dims[0], sizeof(double)),
-		     (int *) R_alloc(dims[0], sizeof(int)), &info);
+    SPL_CALL(dppcon)(*uplo_P(Chol), *dims,
+		     REAL(GET_SLOT(Chol, Matrix_xSym)), anorm, &rcond, &info);
     return ScalarReal(rcond);
 }
 
@@ -62,7 +59,7 @@
     slot_dup(val, Chol, Matrix_uploSym);
     slot_dup(val, Chol, Matrix_xSym);
     slot_dup(val, Chol, Matrix_DimSym);
-    F77_CALL(dpptri)(uplo_P(val), dims,
+    SPL_CALL(dpptri)(*uplo_P(val), *dims,
 		     REAL(GET_SLOT(val, Matrix_xSym)), &info);
     UNPROTECT(1);
     return val;
@@ -78,9 +75,9 @@
 
     if (*adims != *bdims || bdims[1] < 1 || *adims < 1)
 	error(_("Dimensions of system to be solved are inconsistent"));
-    F77_CALL(dpptrs)(uplo_P(Chol), &n, &nrhs,
+    SPL_CALL(dpptrs)(*uplo_P(Chol), n, nrhs,
 		     REAL(GET_SLOT(Chol, Matrix_xSym)),
-		     REAL(GET_SLOT(val, Matrix_xSym)), &n, &info);
+		     REAL(GET_SLOT(val, Matrix_xSym)), n, &info);
     UNPROTECT(1);
     return val;
 }
--- Matrix/src/dppMatrix.h.orig	Mon Jun  4 19:13:02 2007
+++ Matrix/src/dppMatrix.h	Tue Dec 29 04:23:04 2009
@@ -10,6 +10,6 @@
 SEXP dppMatrix_solve(SEXP a);
 SEXP dppMatrix_matrix_solve(SEXP a, SEXP b);
 SEXP dppMatrix_chol(SEXP x);
-double get_norm_sp(SEXP obj, const char *typstr);
+double get_norm_sp(SEXP obj, const char typstr);
 
 #endif
--- Matrix/src/dspMatrix.c.orig	Tue Mar  4 22:44:41 2008
+++ Matrix/src/dspMatrix.c	Tue Dec 29 06:07:35 2009
@@ -15,39 +15,34 @@
     }
 }
 
-double get_norm_sp(SEXP obj, const char *typstr)
+double get_norm_sp(SEXP obj, const char typstr)
 {
-    char typnm[] = {'\0', '\0'};
     int *dims = INTEGER(GET_SLOT(obj, Matrix_DimSym));
     double *work = (double *) NULL;
 
-    typnm[0] = La_norm_type(typstr);
-    if (*typnm == 'I' || *typnm == 'O') {
+    char typnm = La_norm_type(typstr);
+    if (typnm == 'I' || typnm == 'O') {
 	work = (double *) R_alloc(dims[0], sizeof(double));
     }
-    return F77_CALL(dlansp)(typnm, uplo_P(obj), dims,
+    return F77_CALL(dlansp)(&typnm, uplo_P(obj), dims,
 			    REAL(GET_SLOT(obj, Matrix_xSym)), work);
 }
 
 SEXP dspMatrix_norm(SEXP obj, SEXP type)
 {
-    return ScalarReal(get_norm_sp(obj, CHAR(asChar(type))));
+    return ScalarReal(get_norm_sp(obj, *CHAR(asChar(type))));
 }
 
 SEXP dspMatrix_rcond(SEXP obj, SEXP type)
 {
     SEXP trf = dspMatrix_trf(obj);
-    char typnm[] = {'\0', '\0'};
     int *dims = INTEGER(GET_SLOT(obj, Matrix_DimSym)), info;
-    double anorm = get_norm_sp(obj, "O"), rcond;
+    double anorm = get_norm_sp(obj, 'O'), rcond;
 
-    typnm[0] = La_rcond_type(CHAR(asChar(type)));
-    F77_CALL(dspcon)(uplo_P(trf), dims,
+    SPL_CALL(dspcon)(*uplo_P(trf), *dims,
 		     REAL   (GET_SLOT(trf, Matrix_xSym)),
 		     INTEGER(GET_SLOT(trf, Matrix_permSym)),
-		     &anorm, &rcond,
-		     (double *) R_alloc(2*dims[0], sizeof(double)),
-		     (int *) R_alloc(dims[0], sizeof(int)), &info);
+		     anorm, &rcond, &info);
     return ScalarReal(rcond);
 }
 
@@ -60,10 +55,8 @@
     slot_dup(val, trf, Matrix_uploSym);
     slot_dup(val, trf, Matrix_xSym);
     slot_dup(val, trf, Matrix_DimSym);
-    F77_CALL(dsptri)(uplo_P(val), dims, REAL(GET_SLOT(val, Matrix_xSym)),
-		     INTEGER(GET_SLOT(trf, Matrix_permSym)),
-		     (double *) R_alloc((long) dims[0], sizeof(double)),
-		     &info);
+    SPL_CALL(dsptri)(*uplo_P(val), *dims, REAL(GET_SLOT(val, Matrix_xSym)),
+		     INTEGER(GET_SLOT(trf, Matrix_permSym)), &info);
     UNPROTECT(1);
     return val;
 }
@@ -78,10 +71,10 @@
 
     if (adims[0] != n || nrhs < 1 || n < 1)
 	error(_("Dimensions of system to be solved are inconsistent"));
-    F77_CALL(dsptrs)(uplo_P(trf),
-		     &n, &nrhs, REAL(GET_SLOT(trf, Matrix_xSym)),
+    SPL_CALL(dsptrs)(*uplo_P(trf),
+		     n, nrhs, REAL(GET_SLOT(trf, Matrix_xSym)),
 		     INTEGER(GET_SLOT(trf, Matrix_permSym)),
-		     REAL(GET_SLOT(val, Matrix_xSym)), &n, &info);
+		     REAL(GET_SLOT(val, Matrix_xSym)), n, &info);
     UNPROTECT(1);
     return val;
 }
@@ -122,8 +115,8 @@
 /* 	error(_("Matrices with zero extents cannot be multiplied")); */
     } else
 	for (i = 0; i < nrhs; i++)
-	    F77_CALL(dspmv)(uplo, &n, &one, ax, bx + i * n, &ione,
-			    &zero, vx + i * n, &ione);
+	    SPL_CALL(dspmv)(*uplo, n, one, ax, bx + i * n, ione,
+			    zero, vx + i * n, ione);
     UNPROTECT(1);
     return val;
 }
@@ -138,7 +131,6 @@
     const char *uplo = CHAR(STRING_ELT(uploP, 0));
 
     if (val != R_NilValue) return val;
-    dims = INTEGER(dimP);
     val = PROTECT(NEW_OBJECT(MAKE_CLASS("pBunchKaufman")));
     SET_SLOT(val, Matrix_uploSym, duplicate(uploP));
     SET_SLOT(val, Matrix_diagSym, mkString("N"));
@@ -145,9 +137,8 @@
     SET_SLOT(val, Matrix_DimSym, duplicate(dimP));
     slot_dup(val, x, Matrix_xSym);
     perm = INTEGER(ALLOC_SLOT(val, Matrix_permSym, INTSXP, n));
-    F77_CALL(dsptrf)(uplo, dims, REAL(GET_SLOT(val, Matrix_xSym)), perm, &info);
+    SPL_CALL(dsptrf)(*uplo, n, REAL(GET_SLOT(val, Matrix_xSym)), perm, &info);
     if (info) error(_("Lapack routine %s returned error code %d"), "dsptrf", info);
     UNPROTECT(1);
     return set_factors(x, val, "pBunchKaufman");
 }
-
--- Matrix/src/dspMatrix.h.orig	Mon Jun  4 19:13:02 2007
+++ Matrix/src/dspMatrix.h	Tue Dec 29 04:24:12 2009
@@ -5,7 +5,7 @@
 #include "R_ext/Lapack.h"
 
 SEXP dspMatrix_validate(SEXP obj);
-double get_norm_sp(SEXP obj, const char *typstr);
+double get_norm_sp(SEXP obj, const char typstr);
 SEXP dspMatrix_norm(SEXP obj, SEXP type);
 SEXP dspMatrix_rcond(SEXP obj, SEXP type);
 SEXP dspMatrix_solve(SEXP a);
--- Matrix/src/dsyMatrix.c.orig	Tue Sep 23 18:39:50 2008
+++ Matrix/src/dsyMatrix.c	Tue Dec 29 05:07:31 2009
@@ -18,17 +18,16 @@
     return dense_nonpacked_validate(obj);
 }
 
-double get_norm_sy(SEXP obj, const char *typstr)
+double get_norm_sy(SEXP obj, const char typstr)
 {
-    char typnm[] = {'\0', '\0'};
     int *dims = INTEGER(GET_SLOT(obj, Matrix_DimSym));
     double *work = (double *) NULL;
 
-    typnm[0] = La_norm_type(typstr);
-    if (*typnm == 'I' || *typnm == 'O') {
+    char typnm = La_norm_type(typstr);
+    if (typnm == 'I' || typnm == 'O') {
         work = (double *) R_alloc(dims[0], sizeof(double));
     }
-    return F77_CALL(dlansy)(typnm, uplo_P(obj),
+    return F77_CALL(dlansy)(&typnm, uplo_P(obj),
 			    dims, REAL(GET_SLOT(obj, Matrix_xSym)),
 			    dims, work);
 }
@@ -35,7 +34,7 @@
 
 SEXP dsyMatrix_norm(SEXP obj, SEXP type)
 {
-    return ScalarReal(get_norm_sy(obj, CHAR(asChar(type))));
+    return ScalarReal(get_norm_sy(obj, *CHAR(asChar(type))));
 }
 
 
@@ -42,18 +41,14 @@
 SEXP dsyMatrix_rcond(SEXP obj, SEXP type)
 {
     SEXP trf = dsyMatrix_trf(obj);
-    char typnm[] = {'\0', '\0'};
     int *dims = INTEGER(GET_SLOT(obj, Matrix_DimSym)), info;
-    double anorm = get_norm_sy(obj, "O");
+    double anorm = get_norm_sy(obj, 'O');
     double rcond;
 
-    typnm[0] = La_rcond_type(CHAR(asChar(type)));
-    F77_CALL(dsycon)(uplo_P(trf), dims,
-		     REAL   (GET_SLOT(trf, Matrix_xSym)), dims,
+    SPL_CALL(dsycon)(*uplo_P(trf), *dims,
+		     REAL   (GET_SLOT(trf, Matrix_xSym)), *dims,
 		     INTEGER(GET_SLOT(trf, Matrix_permSym)),
-		     &anorm, &rcond,
-		     (double *) R_alloc(2*dims[0], sizeof(double)),
-		     (int *) R_alloc(dims[0], sizeof(int)), &info);
+		     anorm, &rcond, &info);
     return ScalarReal(rcond);
 }
 
@@ -66,10 +61,9 @@
     slot_dup(val, trf, Matrix_uploSym);
     slot_dup(val, trf, Matrix_xSym);
     slot_dup(val, trf, Matrix_DimSym);
-    F77_CALL(dsytri)(uplo_P(val), dims,
-		     REAL(GET_SLOT(val, Matrix_xSym)), dims,
+    SPL_CALL(dsytri)(*uplo_P(val), *dims,
+		     REAL(GET_SLOT(val, Matrix_xSym)), *dims,
 		     INTEGER(GET_SLOT(trf, Matrix_permSym)),
-		     (double *) R_alloc((long) dims[0], sizeof(double)),
 		     &info);
     UNPROTECT(1);
     return val;
@@ -85,11 +79,11 @@
 
     if (*adims != *bdims || bdims[1] < 1 || *adims < 1)
 	error(_("Dimensions of system to be solved are inconsistent"));
-    F77_CALL(dsytrs)(uplo_P(trf), adims, bdims + 1,
-		     REAL(GET_SLOT(trf, Matrix_xSym)), adims,
+    SPL_CALL(dsytrs)(*uplo_P(trf), *adims, bdims[1],
+		     REAL(GET_SLOT(trf, Matrix_xSym)), *adims,
 		     INTEGER(GET_SLOT(trf, Matrix_permSym)),
 		     REAL(GET_SLOT(val, Matrix_xSym)),
-		     bdims, &info);
+		     *bdims, &info);
     UNPROTECT(1);
     return val;
 }
@@ -125,9 +119,9 @@
     if (m < 1 || n < 1) {
 /* 	error(_("Matrices with zero extents cannot be multiplied")); */
     } else
-	F77_CALL(dsymm)(rt ? "R" :"L", uplo_P(a), &m, &n, &one,
-			REAL(GET_SLOT(a, Matrix_xSym)), adims, bcp,
-			&m, &zero, vx, &m);
+	SPL_CALL(dsymm)(rt ? 'R' :'L', *uplo_P(a), m, n, one,
+			REAL(GET_SLOT(a, Matrix_xSym)), *adims, bcp,
+			m, zero, vx, m);
     UNPROTECT(1);
     return val;
 }
@@ -138,9 +132,9 @@
 	dimP = GET_SLOT(x, Matrix_DimSym),
 	uploP = GET_SLOT(x, Matrix_uploSym);
     int *dims = INTEGER(dimP), *perm, info;
-    int lwork = -1, n = dims[0];
+    int n = dims[0];
     const char *uplo = CHAR(STRING_ELT(uploP, 0));
-    double tmp, *vx, *work;
+    double *vx;
 
     if (val != R_NilValue) return val;
     dims = INTEGER(dimP);
@@ -152,11 +146,7 @@
     AZERO(vx, n * n);
     F77_CALL(dlacpy)(uplo, &n, &n, REAL(GET_SLOT(x, Matrix_xSym)), &n, vx, &n);
     perm = INTEGER(ALLOC_SLOT(val, Matrix_permSym, INTSXP, n));
-    F77_CALL(dsytrf)(uplo, &n, vx, &n, perm, &tmp, &lwork, &info);
-    lwork = (int) tmp;
-    work = Alloca(lwork, double);
-    R_CheckStack();
-    F77_CALL(dsytrf)(uplo, &n, vx, &n, perm, work, &lwork, &info);
+    SPL_CALL(dsytrf)(*uplo, n, vx, n, perm, &info);
     if (info) error(_("Lapack routine dsytrf returned error code %d"), info);
     UNPROTECT(1);
     return set_factors(x, val, "BunchKaufman");
--- Matrix/src/dsyMatrix.h.orig	Wed Jul 18 16:46:20 2007
+++ Matrix/src/dsyMatrix.h	Tue Dec 29 04:25:00 2009
@@ -13,6 +13,6 @@
 SEXP dsyMatrix_solve(SEXP a);
 SEXP dsyMatrix_trf(SEXP x);
 SEXP dsyMatrix_validate(SEXP obj);
-double get_norm_sy(SEXP obj, const char *typstr);
+double get_norm_sy(SEXP obj, const char typstr);
 
 #endif
--- Matrix/src/dtpMatrix.c.orig	Tue Mar  4 22:44:41 2008
+++ Matrix/src/dtpMatrix.c	Tue Dec 29 05:09:55 2009
@@ -20,36 +20,31 @@
 }
 
 static
-double get_norm(SEXP obj, const char *typstr)
+double get_norm(SEXP obj, const char typstr)
 {
-    char typnm[] = {'\0', '\0'};
     int *dims = INTEGER(GET_SLOT(obj, Matrix_DimSym));
     double *work = (double *) NULL;
 
-    typnm[0] = La_norm_type(typstr);
-    if (*typnm == 'I') {
+    char typnm = La_norm_type(typstr);
+    if (typnm == 'I') {
 	work = (double *) R_alloc(dims[0], sizeof(double));
     }
-    return F77_CALL(dlantp)(typnm, uplo_P(obj), diag_P(obj), dims,
+    return F77_CALL(dlantp)(&typnm, uplo_P(obj), diag_P(obj), dims,
 			    REAL(GET_SLOT(obj, Matrix_xSym)), work);
 }
 
 SEXP dtpMatrix_norm(SEXP obj, SEXP type)
 {
-    return ScalarReal(get_norm(obj, CHAR(asChar(type))));
+    return ScalarReal(get_norm(obj, *CHAR(asChar(type))));
 }
 
 SEXP dtpMatrix_rcond(SEXP obj, SEXP type)
 {
     int *dims = INTEGER(GET_SLOT(obj, Matrix_DimSym)), info;
-    char typnm[] = {'\0', '\0'};
     double rcond;
-
-    typnm[0] = La_rcond_type(CHAR(asChar(type)));
-    F77_CALL(dtpcon)(typnm, uplo_P(obj), diag_P(obj), dims,
-		     REAL(GET_SLOT(obj, Matrix_xSym)), &rcond,
-		     (double *) R_alloc(3*dims[0], sizeof(double)),
-		     (int *) R_alloc(dims[0], sizeof(int)), &info);
+    char typnm = La_rcond_type(*CHAR(asChar(type)));
+    SPL_CALL(dtpcon)(typnm, *uplo_P(obj), *diag_P(obj), *dims,
+		     REAL(GET_SLOT(obj, Matrix_xSym)), &rcond, &info);
     return ScalarReal(rcond);
 }
 
@@ -57,7 +52,7 @@
 {
     SEXP val = PROTECT(duplicate(a));
     int info, *Dim = INTEGER(GET_SLOT(val, Matrix_DimSym));
-    F77_CALL(dtptri)(uplo_P(val), diag_P(val), Dim,
+    SPL_CALL(dtptri)(*uplo_P(val), *diag_P(val), *Dim,
 		     REAL(GET_SLOT(val, Matrix_xSym)), &info);
     UNPROTECT(1);
     return val;
@@ -100,8 +95,8 @@
 	error(_("Dimensions of a (%d,%d) and b (%d,%d) do not conform"),
 	      xDim[0], xDim[1], yDim[0], yDim[1]);
     for (j = 0; j < yDim[1]; j++) /* X %*% y[,j]  via BLAS 2 DTPMV(.) */
-	F77_CALL(dtpmv)(uplo, "N", diag, yDim, xx,
-			vx + j * yDim[0], &ione);
+	SPL_CALL(dtpmv)(*uplo, 'N', *diag, *yDim, xx,
+			vx + j * yDim[0], ione);
     UNPROTECT(1);
     return val;
 }
@@ -121,8 +116,8 @@
 	error(_("Dimensions of a (%d,%d) and b (%d,%d) do not conform"),
 	      aDim[0], aDim[1], bDim[0], bDim[1]);
     for (j = 0; j < bDim[1]; j++) /* a^{-1} %*% b[,j]  via BLAS 2 DTPSV(.) */
-	F77_CALL(dtpsv)(uplo, "N", diag, bDim, ax,
-			vx + j * bDim[0], &ione);
+	SPL_CALL(dtpsv)(*uplo, 'N', *diag, *bDim, ax,
+			vx + j * bDim[0], ione);
     UNPROTECT(1);
     return val;
 }
@@ -144,8 +139,8 @@
 	error(_("Dimensions of a (%d,%d) and b (%d,%d) do not conform"),
 	      xDim[0], xDim[1], yDim[0], yDim[1]);
     for (i = 0; i < xDim[0]; i++)/* val[i,] := Y' %*% x[i,]  */
-	F77_CALL(dtpmv)(uplo, "T", diag, yDim, yx,
-			vx + i, /* incr = */ xDim);
+	SPL_CALL(dtpmv)(*uplo, 'T', *diag, *yDim, yx,
+			vx + i, /* incr = */ *xDim);
     UNPROTECT(1);
     return val;
 }
--- Matrix/src/dtrMatrix.c.orig	Tue Oct  6 11:32:05 2009
+++ Matrix/src/dtrMatrix.c	Tue Dec 29 05:15:13 2009
@@ -25,17 +25,15 @@
 
 
 static
-double get_norm(SEXP obj, const char *typstr)
+double get_norm(SEXP obj, const char typstr)
 {
-    char typnm[] = {'\0', '\0'};
     int *dims = INTEGER(GET_SLOT(obj, Matrix_DimSym));
     double *work = (double *) NULL;
-
-    typnm[0] = La_norm_type(typstr);
-    if (*typnm == 'I') {
+    char typnm = La_norm_type(typstr);
+    if (typnm == 'I') {
 	work = (double *) R_alloc(dims[0], sizeof(double));
     }
-    return F77_CALL(dlantr)(typnm, uplo_P(obj), diag_P(obj), dims, dims+1,
+    return F77_CALL(dlantr)(&typnm, uplo_P(obj), diag_P(obj), dims, dims+1,
 			    REAL(GET_SLOT(obj, Matrix_xSym)), dims, work);
 }
 
@@ -42,20 +40,16 @@
 
 SEXP dtrMatrix_norm(SEXP obj, SEXP type)
 {
-    return ScalarReal(get_norm(obj, CHAR(asChar(type))));
+    return ScalarReal(get_norm(obj, *CHAR(asChar(type))));
 }
 
 SEXP dtrMatrix_rcond(SEXP obj, SEXP type)
 {
-    char typnm[] = {'\0', '\0'};
     int *dims = INTEGER(GET_SLOT(obj, Matrix_DimSym)), info;
     double rcond;
-
-    typnm[0] = La_rcond_type(CHAR(asChar(type)));
-    F77_CALL(dtrcon)(typnm, uplo_P(obj), diag_P(obj), dims,
-		     REAL(GET_SLOT(obj, Matrix_xSym)), dims, &rcond,
-		     (double *) R_alloc(3*dims[0], sizeof(double)),
-		     (int *) R_alloc(dims[0], sizeof(int)), &info);
+    char typnm = La_rcond_type(*CHAR(asChar(type)));
+    SPL_CALL(dtrcon)(typnm, *uplo_P(obj), *diag_P(obj), *dims,
+		     REAL(GET_SLOT(obj, Matrix_xSym)), *dims, &rcond, &info);
     return ScalarReal(rcond);
 }
 
@@ -63,8 +57,8 @@
 {
     SEXP val = PROTECT(duplicate(a));
     int info, *Dim = INTEGER(GET_SLOT(val, Matrix_DimSym));
-    F77_CALL(dtrtri)(uplo_P(val), diag_P(val), Dim,
-		     REAL(GET_SLOT(val, Matrix_xSym)), Dim, &info);
+    SPL_CALL(dtrtri)(*uplo_P(val), *diag_P(val), *Dim,
+		     REAL(GET_SLOT(val, Matrix_xSym)), *Dim, &info);
     UNPROTECT(1);
     return val;
 }
@@ -80,8 +74,8 @@
     slot_dup(val, a, Matrix_DimNamesSym);
     slot_dup(val, a, Matrix_xSym);
     n = *INTEGER(GET_SLOT(val, Matrix_DimSym));
-    F77_CALL(dpotri)(uplo_P(val), &n,
-		     REAL(GET_SLOT(val, Matrix_xSym)), &n, &info);
+    SPL_CALL(dpotri)(*uplo_P(val), n,
+		     REAL(GET_SLOT(val, Matrix_xSym)), n, &info);
     UNPROTECT(1);
     return val;
 }
@@ -96,9 +90,9 @@
 
     if (*adims != *bdims || bdims[1] < 1 || *adims < 1 || *adims != adims[1])
 	error(_("Dimensions of system to be solved are inconsistent"));
-    F77_CALL(dtrsm)("L", uplo_P(a), "N", diag_P(a),
-		    &n, &nrhs, &one, REAL(GET_SLOT(a, Matrix_xSym)), &n,
-		    REAL(GET_SLOT(ans, Matrix_xSym)), &n);
+    SPL_CALL(dtrsm)('L', *uplo_P(a), 'N', *diag_P(a),
+		    n, nrhs, one, REAL(GET_SLOT(a, Matrix_xSym)), n,
+		    REAL(GET_SLOT(ans, Matrix_xSym)), n);
     UNPROTECT(1);
     return ans;
 }
@@ -121,9 +115,9 @@
     if (m < 1 || n < 1) {
 /* 	error(_("Matrices with zero extents cannot be multiplied")); */
     } else
-	F77_CALL(dtrmm)(rt ? "R" : "L", uplo_P(a), "N", diag_P(a), &m, &n, &one,
-			REAL(GET_SLOT(a, Matrix_xSym)), adims,
-			REAL(GET_SLOT(val, Matrix_xSym)), &m);
+	SPL_CALL(dtrmm)(rt ? 'R' : 'L', *uplo_P(a), 'N', *diag_P(a), m, n, one,
+			REAL(GET_SLOT(a, Matrix_xSym)), *adims,
+			REAL(GET_SLOT(val, Matrix_xSym)), m);
     UNPROTECT(1);
     return val;
 }
@@ -181,9 +175,9 @@
     if (m < 1 || n < 1 || k < 1) {
 /* 	error(_("Matrices with zero extents cannot be multiplied")); */
     } else
-	F77_CALL(dtrmm)("R", uplo_P(a), "N", diag_P(a), adims, bdims+1, &one,
-			REAL(GET_SLOT(a, Matrix_xSym)), adims,
-			REAL(GET_SLOT(val, Matrix_xSym)), bdims);
+	SPL_CALL(dtrmm)('R', *uplo_P(a), 'N', *diag_P(a), m, n, one,
+			REAL(GET_SLOT(a, Matrix_xSym)), m,
+			REAL(GET_SLOT(val, Matrix_xSym)), k);
     UNPROTECT(1);
     return val;
 }