# HG changeset patch
# User jwe
# Date 1161913556 0
# Node ID 143b556ce725021ec3ea042f26fbb438470c631c
# Parent  6465ca8e4f0c366330b8ae81f8d5a383836216da
[project @ 2006-10-27 01:45:54 by jwe]

diff --git a/liboctave/Array-C.cc b/liboctave/Array-C.cc
--- a/liboctave/Array-C.cc
+++ b/liboctave/Array-C.cc
@@ -41,19 +41,19 @@
 
 #include "Array2.h"
 
-template class Array2<Complex>;
+template class OCTAVE_API Array2<Complex>;
 
 #include "ArrayN.h"
 #include "ArrayN.cc"
 
-template class ArrayN<Complex>;
+template class OCTAVE_API ArrayN<Complex>;
 
-template std::ostream& operator << (std::ostream&, const ArrayN<Complex>&);
+template OCTAVE_API std::ostream& operator << (std::ostream&, const ArrayN<Complex>&);
 
 #include "DiagArray2.h"
 #include "DiagArray2.cc"
 
-template class DiagArray2<Complex>;
+template class OCTAVE_API DiagArray2<Complex>;
 
 /*
 ;;; Local Variables: ***
diff --git a/liboctave/Array-b.cc b/liboctave/Array-b.cc
--- a/liboctave/Array-b.cc
+++ b/liboctave/Array-b.cc
@@ -34,19 +34,19 @@
 
 #include "Array2.h"
 
-template class Array2<bool>;
+template class OCTAVE_API Array2<bool>;
 
 #include "ArrayN.h"
 #include "ArrayN.cc"
 
-template class ArrayN<bool>;
+template class OCTAVE_API ArrayN<bool>;
 
-template std::ostream& operator << (std::ostream&, const ArrayN<bool>&);
+template OCTAVE_API std::ostream& operator << (std::ostream&, const ArrayN<bool>&);
 
 #include "DiagArray2.h"
 #include "DiagArray2.cc"
 
-template class DiagArray2<bool>;
+template class OCTAVE_API DiagArray2<bool>;
 
 /*
 ;;; Local Variables: ***
diff --git a/liboctave/Array-ch.cc b/liboctave/Array-ch.cc
--- a/liboctave/Array-ch.cc
+++ b/liboctave/Array-ch.cc
@@ -34,19 +34,19 @@
 
 #include "Array2.h"
 
-template class Array2<char>;
+template class OCTAVE_API Array2<char>;
 
 #include "ArrayN.h"
 #include "ArrayN.cc"
 
-template class ArrayN<char>;
+template class OCTAVE_API ArrayN<char>;
 
-template std::ostream& operator << (std::ostream&, const ArrayN<char>&);
+template OCTAVE_API std::ostream& operator << (std::ostream&, const ArrayN<char>&);
 
 #include "DiagArray2.h"
 #include "DiagArray2.cc"
 
-template class DiagArray2<char>;
+template class OCTAVE_API DiagArray2<char>;
 
 /*
 ;;; Local Variables: ***
diff --git a/liboctave/Array-i.cc b/liboctave/Array-i.cc
--- a/liboctave/Array-i.cc
+++ b/liboctave/Array-i.cc
@@ -50,12 +50,12 @@
 
 #include "Array2.h"
 
-template class Array2<int>;
+template class OCTAVE_API Array2<int>;
 
 #include "DiagArray2.h"
 #include "DiagArray2.cc"
 
-template class DiagArray2<int>;
+template class OCTAVE_API DiagArray2<int>;
 
 /*
 ;;; Local Variables: ***
diff --git a/liboctave/Array-util.h b/liboctave/Array-util.h
--- a/liboctave/Array-util.h
+++ b/liboctave/Array-util.h
@@ -31,61 +31,61 @@
 #include "idx-vector.h"
 #include "lo-error.h"
 
-extern bool index_in_bounds (const Array<octave_idx_type>& ra_idx,
+extern OCTAVE_API bool index_in_bounds (const Array<octave_idx_type>& ra_idx,
 			     const dim_vector& dimensions);
 
-extern void increment_index (Array<octave_idx_type>& ra_idx,
+extern OCTAVE_API void increment_index (Array<octave_idx_type>& ra_idx,
 			     const dim_vector& dimensions,
 			     int start_dimension = 0);
 
-extern octave_idx_type get_scalar_idx (Array<octave_idx_type>& idx, dim_vector& dims);
+extern OCTAVE_API octave_idx_type get_scalar_idx (Array<octave_idx_type>& idx, dim_vector& dims);
 
-extern octave_idx_type num_ones (const Array<octave_idx_type>& ra_idx);
+extern OCTAVE_API octave_idx_type num_ones (const Array<octave_idx_type>& ra_idx);
 
-extern bool is_scalar (const dim_vector& dim);
+extern OCTAVE_API bool is_scalar (const dim_vector& dim);
 
-extern bool any_ones (const Array<octave_idx_type>& arr);
+extern OCTAVE_API bool any_ones (const Array<octave_idx_type>& arr);
 
-extern octave_idx_type compute_index (const Array<octave_idx_type>& ra_idx, const dim_vector& dims);
+extern OCTAVE_API octave_idx_type compute_index (const Array<octave_idx_type>& ra_idx, const dim_vector& dims);
 
-extern Array<octave_idx_type> conv_to_int_array (const Array<idx_vector>& a);
+extern OCTAVE_API Array<octave_idx_type> conv_to_int_array (const Array<idx_vector>& a);
 
-extern Array<idx_vector> conv_to_array (const idx_vector *tmp, const octave_idx_type len);
+extern OCTAVE_API Array<idx_vector> conv_to_array (const idx_vector *tmp, const octave_idx_type len);
 
-extern dim_vector freeze (Array<idx_vector>& ra_idx,
+extern OCTAVE_API dim_vector freeze (Array<idx_vector>& ra_idx,
 			  const dim_vector& dimensions, int resize_ok);
 
-extern bool vector_equivalent (const dim_vector& dv);
+extern OCTAVE_API bool vector_equivalent (const dim_vector& dv);
 
-extern bool all_ok (const Array<idx_vector>& ra_idx);
+extern OCTAVE_API bool all_ok (const Array<idx_vector>& ra_idx);
 
-extern bool any_orig_empty (const Array<idx_vector>& ra_idx);
+extern OCTAVE_API bool any_orig_empty (const Array<idx_vector>& ra_idx);
 
-extern bool all_colon_equiv (const Array<idx_vector>& ra_idx,
+extern OCTAVE_API bool all_colon_equiv (const Array<idx_vector>& ra_idx,
 			     const dim_vector& frozen_lengths);
 
-extern bool is_in (octave_idx_type num, const idx_vector& idx);
+extern OCTAVE_API bool is_in (octave_idx_type num, const idx_vector& idx);
 
-extern octave_idx_type how_many_lgt (const octave_idx_type num, idx_vector& idxv);
+extern OCTAVE_API octave_idx_type how_many_lgt (const octave_idx_type num, idx_vector& idxv);
 
-extern bool all_ones (const Array<octave_idx_type>& arr);
+extern OCTAVE_API bool all_ones (const Array<octave_idx_type>& arr);
 
-extern Array<octave_idx_type> get_elt_idx (const Array<idx_vector>& ra_idx,
+extern OCTAVE_API Array<octave_idx_type> get_elt_idx (const Array<idx_vector>& ra_idx,
 			       const Array<octave_idx_type>& result_idx);
 
-extern Array<octave_idx_type> get_ra_idx (octave_idx_type idx, const dim_vector& dims);
+extern OCTAVE_API Array<octave_idx_type> get_ra_idx (octave_idx_type idx, const dim_vector& dims);
 
-extern dim_vector short_freeze (Array<idx_vector>& ra_idx,
+extern OCTAVE_API dim_vector short_freeze (Array<idx_vector>& ra_idx,
 				const dim_vector& dimensions,
 				int resize_ok);
 
-extern void gripe_nonconformant (const char *op, int op1_len, int op2_len);
+extern void OCTAVE_API gripe_nonconformant (const char *op, int op1_len, int op2_len);
 
-extern void gripe_nonconformant (const char *op, int op1_nr, int op1_nc,
+extern void OCTAVE_API gripe_nonconformant (const char *op, int op1_nr, int op1_nc,
 				 int op2_nr, int op2_nc);
 
 
-extern void gripe_nonconformant (const char *op, dim_vector& op1_dims,
+extern void OCTAVE_API gripe_nonconformant (const char *op, dim_vector& op1_dims,
 				 dim_vector& op2_dims);
 
 #endif
diff --git a/liboctave/Array.h b/liboctave/Array.h
--- a/liboctave/Array.h
+++ b/liboctave/Array.h
@@ -570,16 +570,16 @@
 }
 
 #define INSTANTIATE_ARRAY_ASSIGN(LT, RT) \
-  template int assign (Array<LT>&, const Array<RT>&, const LT&); \
-  template int assign1 (Array<LT>&, const Array<RT>&, const LT&); \
-  template int assign2 (Array<LT>&, const Array<RT>&, const LT&); \
-  template int assignN (Array<LT>&, const Array<RT>&, const LT&); \
-  template int assign (Array<LT>&, const Array<RT>&)
+  template OCTAVE_API int assign (Array<LT>&, const Array<RT>&, const LT&); \
+  template OCTAVE_API int assign1 (Array<LT>&, const Array<RT>&, const LT&); \
+  template OCTAVE_API int assign2 (Array<LT>&, const Array<RT>&, const LT&); \
+  template OCTAVE_API int assignN (Array<LT>&, const Array<RT>&, const LT&); \
+  template OCTAVE_API int assign (Array<LT>&, const Array<RT>&)
 
 
 #define INSTANTIATE_ARRAY(T) \
-  template class Array<T>; \
-  template T resize_fill_value (const T&); \
+  template class OCTAVE_API Array<T>; \
+  template OCTAVE_API T resize_fill_value (const T&); \
 
 #define INSTANTIATE_ARRAY_AND_ASSIGN(T) \
   INSTANTIATE_ARRAY (T); \
diff --git a/liboctave/CColVector.h b/liboctave/CColVector.h
--- a/liboctave/CColVector.h
+++ b/liboctave/CColVector.h
@@ -29,6 +29,7 @@
 #include "mx-defs.h"
 
 class
+OCTAVE_API
 ComplexColumnVector : public MArray<Complex>
 {
 friend class ComplexMatrix;
diff --git a/liboctave/CMatrix.h b/liboctave/CMatrix.h
--- a/liboctave/CMatrix.h
+++ b/liboctave/CMatrix.h
@@ -33,6 +33,7 @@
 #include "oct-cmplx.h"
 
 class
+OCTAVE_API
 ComplexMatrix : public MArray2<Complex>
 {
 public:
@@ -319,8 +320,8 @@
 
   // i/o
 
-  friend std::ostream& operator << (std::ostream& os, const ComplexMatrix& a);
-  friend std::istream& operator >> (std::istream& is, ComplexMatrix& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const ComplexMatrix& a);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is, ComplexMatrix& a);
 
   static Complex resize_fill_value (void) { return Complex (0.0, 0.0); }
 
@@ -331,32 +332,32 @@
 
 // column vector by row vector -> matrix operations
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 operator * (const ColumnVector& a, const ComplexRowVector& b);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 operator * (const ComplexColumnVector& a, const RowVector& b);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 operator * (const ComplexColumnVector& a, const ComplexRowVector& b);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 Givens (const Complex&, const Complex&);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 Sylvester (const ComplexMatrix&, const ComplexMatrix&, const ComplexMatrix&);
 
-extern ComplexMatrix operator * (const Matrix&,        const ComplexMatrix&);
-extern ComplexMatrix operator * (const ComplexMatrix&, const Matrix&);
-extern ComplexMatrix operator * (const ComplexMatrix&, const ComplexMatrix&);
+extern OCTAVE_API ComplexMatrix operator * (const Matrix&,        const ComplexMatrix&);
+extern OCTAVE_API ComplexMatrix operator * (const ComplexMatrix&, const Matrix&);
+extern OCTAVE_API ComplexMatrix operator * (const ComplexMatrix&, const ComplexMatrix&);
 
-extern ComplexMatrix min (const Complex& c, const ComplexMatrix& m);
-extern ComplexMatrix min (const ComplexMatrix& m, const Complex& c);
-extern ComplexMatrix min (const ComplexMatrix& a, const ComplexMatrix& b);
+extern OCTAVE_API ComplexMatrix min (const Complex& c, const ComplexMatrix& m);
+extern OCTAVE_API ComplexMatrix min (const ComplexMatrix& m, const Complex& c);
+extern OCTAVE_API ComplexMatrix min (const ComplexMatrix& a, const ComplexMatrix& b);
 
-extern ComplexMatrix max (const Complex& c, const ComplexMatrix& m);
-extern ComplexMatrix max (const ComplexMatrix& m, const Complex& c);
-extern ComplexMatrix max (const ComplexMatrix& a, const ComplexMatrix& b);
+extern OCTAVE_API ComplexMatrix max (const Complex& c, const ComplexMatrix& m);
+extern OCTAVE_API ComplexMatrix max (const ComplexMatrix& m, const Complex& c);
+extern OCTAVE_API ComplexMatrix max (const ComplexMatrix& a, const ComplexMatrix& b);
 
 MS_CMP_OP_DECLS (ComplexMatrix, Complex)
 MS_BOOL_OP_DECLS (ComplexMatrix, Complex)
diff --git a/liboctave/CNDArray.h b/liboctave/CNDArray.h
--- a/liboctave/CNDArray.h
+++ b/liboctave/CNDArray.h
@@ -31,6 +31,7 @@
 #include "mx-op-defs.h"
 
 class
+OCTAVE_API
 ComplexNDArray : public MArrayN<Complex>
 {
 public:
@@ -108,8 +109,8 @@
 
   // i/o
 
-  friend std::ostream& operator << (std::ostream& os, const ComplexNDArray& a);
-  friend std::istream& operator >> (std::istream& is, ComplexNDArray& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const ComplexNDArray& a);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is, ComplexNDArray& a);
 
   static Complex resize_fill_value (void) { return Complex (0.0, 0.0); }
 
@@ -122,13 +123,13 @@
     : MArrayN<Complex> (d, dv) { }
 };
 
-extern ComplexNDArray min (const Complex& c, const ComplexNDArray& m);
-extern ComplexNDArray min (const ComplexNDArray& m, const Complex& c);
-extern ComplexNDArray min (const ComplexNDArray& a, const ComplexNDArray& b);
+extern OCTAVE_API ComplexNDArray min (const Complex& c, const ComplexNDArray& m);
+extern OCTAVE_API ComplexNDArray min (const ComplexNDArray& m, const Complex& c);
+extern OCTAVE_API ComplexNDArray min (const ComplexNDArray& a, const ComplexNDArray& b);
 
-extern ComplexNDArray max (const Complex& c, const ComplexNDArray& m);
-extern ComplexNDArray max (const ComplexNDArray& m, const Complex& c);
-extern ComplexNDArray max (const ComplexNDArray& a, const ComplexNDArray& b);
+extern OCTAVE_API ComplexNDArray max (const Complex& c, const ComplexNDArray& m);
+extern OCTAVE_API ComplexNDArray max (const ComplexNDArray& m, const Complex& c);
+extern OCTAVE_API ComplexNDArray max (const ComplexNDArray& a, const ComplexNDArray& b);
 
 NDS_CMP_OP_DECLS (ComplexNDArray, Complex)
 NDS_BOOL_OP_DECLS (ComplexNDArray, Complex)
diff --git a/liboctave/CRowVector.h b/liboctave/CRowVector.h
--- a/liboctave/CRowVector.h
+++ b/liboctave/CRowVector.h
@@ -29,6 +29,7 @@
 #include "mx-defs.h"
 
 class
+OCTAVE_API
 ComplexRowVector : public MArray<Complex>
 {
 friend class ComplexColumnVector;
@@ -121,7 +122,7 @@
 
 // other operations
 
-ComplexRowVector linspace (const Complex& x1, const Complex& x2, octave_idx_type n);
+OCTAVE_API ComplexRowVector linspace (const Complex& x1, const Complex& x2, octave_idx_type n);
 
 MARRAY_FORWARD_DEFS (MArray, ComplexRowVector, Complex)
 
diff --git a/liboctave/CSparse.h b/liboctave/CSparse.h
--- a/liboctave/CSparse.h
+++ b/liboctave/CSparse.h
@@ -40,6 +40,7 @@
 class SparseBoolMatrix;
 
 class
+OCTAVE_API
 SparseComplexMatrix : public MSparse<Complex>
 {
 public:
@@ -421,45 +422,45 @@
   SparseComplexMatrix diag (octave_idx_type k = 0) const;
 
   // i/o
-  friend std::ostream& operator << (std::ostream& os, 
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, 
 				    const SparseComplexMatrix& a);
-  friend std::istream& operator >> (std::istream& is, 
+  friend OCTAVE_API std::istream& operator >> (std::istream& is, 
 				    SparseComplexMatrix& a);
 };
 
-extern SparseComplexMatrix operator * (const SparseMatrix&,        
+extern OCTAVE_API SparseComplexMatrix operator * (const SparseMatrix&,        
 				       const SparseComplexMatrix&);
-extern SparseComplexMatrix operator * (const SparseComplexMatrix&, 
+extern OCTAVE_API SparseComplexMatrix operator * (const SparseComplexMatrix&, 
 				       const SparseMatrix&);
-extern SparseComplexMatrix operator * (const SparseComplexMatrix&, 
+extern OCTAVE_API SparseComplexMatrix operator * (const SparseComplexMatrix&, 
 				       const SparseComplexMatrix&);
 
-extern ComplexMatrix operator * (const Matrix&,        
+extern OCTAVE_API ComplexMatrix operator * (const Matrix&,        
 				       const SparseComplexMatrix&);
-extern ComplexMatrix operator * (const ComplexMatrix&, 
+extern OCTAVE_API ComplexMatrix operator * (const ComplexMatrix&, 
 				       const SparseMatrix&);
-extern ComplexMatrix operator * (const ComplexMatrix&, 
+extern OCTAVE_API ComplexMatrix operator * (const ComplexMatrix&, 
 				       const SparseComplexMatrix&);
 
-extern ComplexMatrix operator * (const SparseMatrix&,        
+extern OCTAVE_API ComplexMatrix operator * (const SparseMatrix&,        
 				       const ComplexMatrix&);
-extern ComplexMatrix operator * (const SparseComplexMatrix&, 
+extern OCTAVE_API ComplexMatrix operator * (const SparseComplexMatrix&, 
 				       const Matrix&);
-extern ComplexMatrix operator * (const SparseComplexMatrix&, 
+extern OCTAVE_API ComplexMatrix operator * (const SparseComplexMatrix&, 
 				       const ComplexMatrix&);
 
-extern SparseComplexMatrix min (const Complex& c, 
+extern OCTAVE_API SparseComplexMatrix min (const Complex& c, 
 				const SparseComplexMatrix& m);
-extern SparseComplexMatrix min (const SparseComplexMatrix& m, 
+extern OCTAVE_API SparseComplexMatrix min (const SparseComplexMatrix& m, 
 				const Complex& c);
-extern SparseComplexMatrix min (const SparseComplexMatrix& a, 
+extern OCTAVE_API SparseComplexMatrix min (const SparseComplexMatrix& a, 
 				const SparseComplexMatrix& b);
 
-extern SparseComplexMatrix max (const Complex& c, 
+extern OCTAVE_API SparseComplexMatrix max (const Complex& c, 
 				const SparseComplexMatrix& m);
-extern SparseComplexMatrix max (const SparseComplexMatrix& m, 
+extern OCTAVE_API SparseComplexMatrix max (const SparseComplexMatrix& m, 
 				const Complex& c);
-extern SparseComplexMatrix max (const SparseComplexMatrix& a, 
+extern OCTAVE_API SparseComplexMatrix max (const SparseComplexMatrix& a, 
 				const SparseComplexMatrix& b);
 
 SPARSE_SMS_CMP_OP_DECLS (SparseComplexMatrix, Complex)
diff --git a/liboctave/ChangeLog b/liboctave/ChangeLog
--- a/liboctave/ChangeLog
+++ b/liboctave/ChangeLog
@@ -2,6 +2,52 @@
 
 	* kpse.cc [! MSVC]: Don't include win32lib.h.
 
+	* liboctave/Array-C.cc, liboctave/Array-b.cc,
+	liboctave/Array-ch.cc, liboctave/Array-i.cc,
+	liboctave/Array-util.h, liboctave/Array.h, liboctave/CColVector.h,
+	liboctave/CMatrix.h, liboctave/CNDArray.h, liboctave/CRowVector.h,
+	liboctave/CSparse.h, liboctave/CmplxAEPBAL.h,
+	liboctave/CmplxCHOL.h, liboctave/CmplxDET.h,
+	liboctave/CmplxHESS.h, liboctave/CmplxLU.h, liboctave/CmplxQR.h,
+	liboctave/CmplxQRP.h, liboctave/CmplxSCHUR.h,
+	liboctave/CmplxSVD.h, liboctave/CollocWt.h, liboctave/DAE.h,
+	liboctave/DASPK.h, liboctave/DASRT.h, liboctave/DASSL.h,
+	liboctave/EIG.h, liboctave/LSODE.h, liboctave/MArray-C.cc,
+	liboctave/MArray-defs.h, liboctave/MSparse-C.cc,
+	liboctave/MSparse-d.cc, liboctave/MSparse-defs.h,
+	liboctave/MatrixType.h, liboctave/NLEqn.h, liboctave/Quad.h,
+	liboctave/Range.h, liboctave/Sparse-op-defs.h, liboctave/Sparse.h,
+	liboctave/SparseCmplxCHOL.h, liboctave/SparseCmplxLU.h,
+	liboctave/SparseCmplxQR.h, liboctave/SparseQR.h,
+	liboctave/SparsedbleCHOL.h, liboctave/SparsedbleLU.h,
+	liboctave/boolMatrix.h, liboctave/boolNDArray.h,
+	liboctave/boolSparse.h, liboctave/chMatrix.h,
+	liboctave/chNDArray.h, liboctave/cmd-edit.h, liboctave/cmd-hist.h,
+	liboctave/dColVector.h, liboctave/dDiagMatrix.h,
+	liboctave/dMatrix.h, liboctave/dNDArray.h, liboctave/dRowVector.h,
+	liboctave/dSparse.h, liboctave/data-conv.h,
+	liboctave/dbleAEPBAL.h, liboctave/dbleCHOL.h, liboctave/dbleDET.h,
+	liboctave/dbleHESS.h, liboctave/dbleLU.h, liboctave/dbleQR.h,
+	liboctave/dbleQRP.h, liboctave/dbleSCHUR.h, liboctave/dbleSVD.h,
+	liboctave/dir-ops.h, liboctave/file-ops.h, liboctave/file-stat.h,
+	liboctave/glob-match.h, liboctave/idx-vector.h,
+	liboctave/int16NDArray.cc, liboctave/int32NDArray.cc,
+	liboctave/int64NDArray.cc, liboctave/int8NDArray.cc,
+	liboctave/lo-cutils.c, liboctave/lo-ieee.h,
+	liboctave/lo-mappers.h, liboctave/lo-specfun.h,
+	liboctave/lo-utils.h, liboctave/mach-info.h,
+	liboctave/mx-op-defs.h, liboctave/oct-alloc.h,
+	liboctave/oct-env.h, liboctave/oct-group.h,
+	liboctave/oct-inttypes.cc, liboctave/oct-inttypes.h,
+	liboctave/oct-passwd.h, liboctave/oct-rand.h,
+	liboctave/oct-shlib.h, liboctave/oct-spparms.h,
+	liboctave/oct-syscalls.h, liboctave/oct-time.h,
+	liboctave/oct-uname.h, liboctave/pathsearch.h,
+	liboctave/prog-args.h, liboctave/so-array.h, liboctave/str-vec.h,
+	liboctave/uint16NDArray.cc, liboctave/uint32NDArray.cc,
+	liboctave/uint64NDArray.cc, liboctave/uint8NDArray.cc:
+	Sprinkle with OCTAVE_API as needed.
+
 2006-10-26  John W. Eaton  <jwe@octave.org>
 
 	* oct-inttypes.cc (INSTANTIATE_INTTYPE_BIN_OP): Provide explicit
diff --git a/liboctave/CmplxAEPBAL.h b/liboctave/CmplxAEPBAL.h
--- a/liboctave/CmplxAEPBAL.h
+++ b/liboctave/CmplxAEPBAL.h
@@ -30,6 +30,7 @@
 #include "CMatrix.h"
 
 class
+OCTAVE_API
 ComplexAEPBALANCE
 {
 public:
diff --git a/liboctave/CmplxCHOL.h b/liboctave/CmplxCHOL.h
--- a/liboctave/CmplxCHOL.h
+++ b/liboctave/CmplxCHOL.h
@@ -29,6 +29,7 @@
 #include "CMatrix.h"
 
 class
+OCTAVE_API
 ComplexCHOL
 {
 public:
@@ -57,7 +58,7 @@
 
   ComplexMatrix inverse (void) const;
 
-  friend std::ostream& operator << (std::ostream& os, const ComplexCHOL& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const ComplexCHOL& a);
 
 private:
 
@@ -66,7 +67,7 @@
   octave_idx_type init (const ComplexMatrix& a);
 };
 
-ComplexMatrix chol2inv (const ComplexMatrix& r);
+ComplexMatrix OCTAVE_API chol2inv (const ComplexMatrix& r);
 
 #endif
 
diff --git a/liboctave/CmplxDET.h b/liboctave/CmplxDET.h
--- a/liboctave/CmplxDET.h
+++ b/liboctave/CmplxDET.h
@@ -31,6 +31,7 @@
 // FIXME -- we could use templates here; compare with dbleDET.h
 
 class
+OCTAVE_API
 ComplexDET
 {
 friend class ComplexMatrix;
diff --git a/liboctave/CmplxHESS.h b/liboctave/CmplxHESS.h
--- a/liboctave/CmplxHESS.h
+++ b/liboctave/CmplxHESS.h
@@ -29,6 +29,7 @@
 #include "CMatrix.h"
 
 class
+OCTAVE_API
 ComplexHESS
 {
 public:
diff --git a/liboctave/CmplxLU.h b/liboctave/CmplxLU.h
--- a/liboctave/CmplxLU.h
+++ b/liboctave/CmplxLU.h
@@ -29,6 +29,7 @@
 #include "CMatrix.h"
 
 class
+OCTAVE_API
 ComplexLU : public base_lu <ComplexMatrix, Complex, Matrix, double>
 {
 public:
diff --git a/liboctave/CmplxQR.h b/liboctave/CmplxQR.h
--- a/liboctave/CmplxQR.h
+++ b/liboctave/CmplxQR.h
@@ -30,6 +30,7 @@
 #include "dbleQR.h"
 
 class
+OCTAVE_API
 ComplexQR
 {
 public:
diff --git a/liboctave/CmplxQRP.h b/liboctave/CmplxQRP.h
--- a/liboctave/CmplxQRP.h
+++ b/liboctave/CmplxQRP.h
@@ -29,6 +29,7 @@
 #include "CmplxQR.h"
 
 class
+OCTAVE_API
 ComplexQRP : public ComplexQR
 {
 public:
diff --git a/liboctave/CmplxSCHUR.h b/liboctave/CmplxSCHUR.h
--- a/liboctave/CmplxSCHUR.h
+++ b/liboctave/CmplxSCHUR.h
@@ -30,6 +30,7 @@
 #include "CMatrix.h"
 
 class
+OCTAVE_API
 ComplexSCHUR
 {
 public:
diff --git a/liboctave/CmplxSVD.h b/liboctave/CmplxSVD.h
--- a/liboctave/CmplxSVD.h
+++ b/liboctave/CmplxSVD.h
@@ -31,6 +31,7 @@
 #include "dbleSVD.h"
 
 class
+OCTAVE_API
 ComplexSVD
 {
 public:
diff --git a/liboctave/CollocWt.h b/liboctave/CollocWt.h
--- a/liboctave/CollocWt.h
+++ b/liboctave/CollocWt.h
@@ -30,6 +30,7 @@
 #include "dColVector.h"
 
 class
+OCTAVE_API
 CollocWt
 {
 public:
diff --git a/liboctave/DAE.h b/liboctave/DAE.h
--- a/liboctave/DAE.h
+++ b/liboctave/DAE.h
@@ -28,6 +28,7 @@
 #include "base-dae.h"
 
 class
+OCTAVE_API
 DAE : public base_diff_alg_eqn, public DAEFunc
 {
 public:
diff --git a/liboctave/DASPK.h b/liboctave/DASPK.h
--- a/liboctave/DASPK.h
+++ b/liboctave/DASPK.h
@@ -30,6 +30,7 @@
 #include "DASPK-opts.h"
 
 class
+OCTAVE_API
 DASPK : public DAE, public DASPK_options
 {
 public:
diff --git a/liboctave/DASRT.h b/liboctave/DASRT.h
--- a/liboctave/DASRT.h
+++ b/liboctave/DASRT.h
@@ -67,6 +67,7 @@
 };
 
 class
+OCTAVE_API
 DASRT : public DAERT, public DASRT_options
 {
 public:
diff --git a/liboctave/DASSL.h b/liboctave/DASSL.h
--- a/liboctave/DASSL.h
+++ b/liboctave/DASSL.h
@@ -30,6 +30,7 @@
 #include "DASSL-opts.h"
 
 class
+OCTAVE_API
 DASSL : public DAE, public DASSL_options
 {
 public:
diff --git a/liboctave/EIG.h b/liboctave/EIG.h
--- a/liboctave/EIG.h
+++ b/liboctave/EIG.h
@@ -31,6 +31,7 @@
 #include "CColVector.h"
 
 class
+OCTAVE_API
 EIG
 {
 friend class Matrix;
diff --git a/liboctave/LSODE.h b/liboctave/LSODE.h
--- a/liboctave/LSODE.h
+++ b/liboctave/LSODE.h
@@ -30,6 +30,7 @@
 #include "LSODE-opts.h"
 
 class
+OCTAVE_API
 LSODE : public ODE, public LSODE_options
 {
 public:
diff --git a/liboctave/MArray-C.cc b/liboctave/MArray-C.cc
--- a/liboctave/MArray-C.cc
+++ b/liboctave/MArray-C.cc
@@ -32,28 +32,28 @@
 #include "MArray.h"
 #include "MArray.cc"
 
-template class MArray<Complex>;
+template class OCTAVE_API MArray<Complex>;
 
 INSTANTIATE_MARRAY_FRIENDS (Complex)
 
 #include "MArray2.h"
 #include "MArray2.cc"
 
-template class MArray2<Complex>;
+template class OCTAVE_API MArray2<Complex>;
 
 INSTANTIATE_MARRAY2_FRIENDS (Complex)
 
 #include "MArrayN.h"
 #include "MArrayN.cc"
 
-template class MArrayN<Complex>;
+template class OCTAVE_API MArrayN<Complex>;
 
 INSTANTIATE_MARRAYN_FRIENDS (Complex)
 
 #include "MDiagArray2.h"
 #include "MDiagArray2.cc"
 
-template class MDiagArray2<Complex>;
+template class OCTAVE_API MDiagArray2<Complex>;
 
 INSTANTIATE_MDIAGARRAY2_FRIENDS (Complex)
 
diff --git a/liboctave/MArray-defs.h b/liboctave/MArray-defs.h
--- a/liboctave/MArray-defs.h
+++ b/liboctave/MArray-defs.h
@@ -62,7 +62,7 @@
 
 // Generate forward declarations for OP= operators.
 #define MARRAY_OP_ASSIGN_FWD_DECLS(A_T, RHS_T) \
-  MARRAY_OP_ASSIGN_DECLS (A_T, T, template <typename T>, , RHS_T)
+  MARRAY_OP_ASSIGN_DECLS (A_T, T, template <typename T> OCTAVE_API, , RHS_T)
 
 // Generate friend declarations for the OP= operators.
 #define MARRAY_OP_ASSIGN_FRIENDS(A_T, RHS_T) \
@@ -70,7 +70,7 @@
 
 // Instantiate the OP= operators.
 #define MARRAY_OP_ASSIGN_DEFS(A_T, E_T, RHS_T) \
-  MARRAY_OP_ASSIGN_DECLS (A_T, E_T, template, , RHS_T)
+  MARRAY_OP_ASSIGN_DECLS (A_T, E_T, template OCTAVE_API, , RHS_T)
 
 // A function that can be used to forward OP= operations from derived
 // classes back to us.
@@ -98,7 +98,7 @@
 
 // Generate forward declarations for unary operators.
 #define MARRAY_UNOP_FWD_DECLS(A_T) \
-  MARRAY_UNOP_DECLS (A_T, T, template <typename T>, )
+  MARRAY_UNOP_DECLS (A_T, T, template <typename T> OCTAVE_API, )
 
 // Generate friend declarations for the unary operators.
 #define MARRAY_UNOP_FRIENDS(A_T) \
@@ -106,7 +106,7 @@
 
 // Instantiate the unary operators.
 #define MARRAY_UNOP_DEFS(A_T, E_T) \
-  MARRAY_UNOP_DECLS (A_T, E_T, template, )
+  MARRAY_UNOP_DECLS (A_T, E_T, template OCTAVE_API, )
 
 // A function that can be used to forward unary operations from derived
 // classes back to us.
@@ -156,9 +156,9 @@
 
 // Generate forward declarations for binary operators.
 #define MARRAY_BINOP_FWD_DECLS(A_T) \
-  MARRAY_BINOP_DECLS (A_T, T, template <typename T>, , A_T<T>, T) \
-  MARRAY_BINOP_DECLS (A_T, T, template <typename T>, , T, A_T<T>) \
-  MARRAY_AA_BINOP_DECLS (A_T, T, template <typename T>, )
+  MARRAY_BINOP_DECLS (A_T, T, template <typename T> OCTAVE_API, , A_T<T>, T) \
+  MARRAY_BINOP_DECLS (A_T, T, template <typename T> OCTAVE_API, , T, A_T<T>) \
+  MARRAY_AA_BINOP_DECLS (A_T, T, template <typename T> OCTAVE_API, )
 
 #define MDIAGARRAY2_BINOP_FWD_DECLS(A_T) \
   MDIAGARRAY2_DAS_BINOP_DECLS (A_T, T, template <typename T>, , A_T<T>, T) \
@@ -178,14 +178,14 @@
 
 // Instantiate the binary operators.
 #define MARRAY_BINOP_DEFS(A_T, E_T) \
-  MARRAY_BINOP_DECLS (A_T, E_T, template, , A_T<E_T>, E_T) \
-  MARRAY_BINOP_DECLS (A_T, E_T, template, , E_T, A_T<E_T>) \
-  MARRAY_AA_BINOP_DECLS (A_T, E_T, template, )
+  MARRAY_BINOP_DECLS (A_T, E_T, template OCTAVE_API, , A_T<E_T>, E_T) \
+  MARRAY_BINOP_DECLS (A_T, E_T, template OCTAVE_API, , E_T, A_T<E_T>) \
+  MARRAY_AA_BINOP_DECLS (A_T, E_T, template OCTAVE_API, )
 
 #define MDIAGARRAY2_BINOP_DEFS(A_T, E_T) \
-  MDIAGARRAY2_DAS_BINOP_DECLS (A_T, E_T, template, , A_T<E_T>, E_T) \
-  MDIAGARRAY2_SDA_BINOP_DECLS (A_T, E_T, template, , E_T, A_T<E_T>) \
-  MDIAGARRAY2_DADA_BINOP_DECLS (A_T, E_T, template, )
+  MDIAGARRAY2_DAS_BINOP_DECLS (A_T, E_T, template OCTAVE_API, , A_T<E_T>, E_T) \
+  MDIAGARRAY2_SDA_BINOP_DECLS (A_T, E_T, template OCTAVE_API, , E_T, A_T<E_T>) \
+  MDIAGARRAY2_DADA_BINOP_DECLS (A_T, E_T, template OCTAVE_API, )
 
 // A function that can be used to forward binary operations from derived
 // classes back to us.
diff --git a/liboctave/MSparse-C.cc b/liboctave/MSparse-C.cc
--- a/liboctave/MSparse-C.cc
+++ b/liboctave/MSparse-C.cc
@@ -29,7 +29,7 @@
 #include "MSparse.h"
 #include "MSparse.cc"
 
-template class MSparse<Complex>;
+template class OCTAVE_API MSparse<Complex>;
 
 INSTANTIATE_SPARSE_FRIENDS (Complex);
 
diff --git a/liboctave/MSparse-d.cc b/liboctave/MSparse-d.cc
--- a/liboctave/MSparse-d.cc
+++ b/liboctave/MSparse-d.cc
@@ -27,7 +27,7 @@
 #include "MSparse.h"
 #include "MSparse.cc"
 
-template class MSparse<double>;
+template class OCTAVE_API MSparse<double>;
 
 INSTANTIATE_SPARSE_FRIENDS (double);
 
diff --git a/liboctave/MSparse-defs.h b/liboctave/MSparse-defs.h
--- a/liboctave/MSparse-defs.h
+++ b/liboctave/MSparse-defs.h
@@ -45,7 +45,7 @@
 
 // Instantiate the OP= operators.
 #define SPARSE_OP_ASSIGN_DEFS(A_T, E_T, RHS_T) \
-  SPARSE_OP_ASSIGN_DECLS (A_T, E_T, template, , RHS_T)
+  SPARSE_OP_ASSIGN_DECLS (A_T, E_T, template OCTAVE_API, , RHS_T)
 
 // A function that can be used to forward OP= operations from derived
 // classes back to us.
@@ -81,7 +81,7 @@
 
 // Instantiate the unary operators.
 #define SPARSE_UNOP_DEFS(A_T, E_T) \
-  SPARSE_UNOP_DECLS (A_T, E_T, template, )
+  SPARSE_UNOP_DECLS (A_T, E_T, template OCTAVE_API, )
 
 // A function that can be used to forward unary operations from derived
 // classes back to us.
@@ -131,9 +131,9 @@
 
 // Instantiate the binary operators.
 #define SPARSE_BINOP_DEFS(A_T, F_T, E_T) \
-  SPARSE_BINOP_DECLS (A_T, F_T, E_T, template, , A_T<E_T>, E_T)	\
-  SPARSE_BINOP_DECLS (A_T, F_T, E_T, template, , E_T, A_T<E_T>)	\
-  SPARSE_AA_BINOP_DECLS (A_T, E_T, template, )
+  SPARSE_BINOP_DECLS (A_T, F_T, E_T, template OCTAVE_API, , A_T<E_T>, E_T)	\
+  SPARSE_BINOP_DECLS (A_T, F_T, E_T, template OCTAVE_API, , E_T, A_T<E_T>)	\
+  SPARSE_AA_BINOP_DECLS (A_T, E_T, template OCTAVE_API, )
 
 // A function that can be used to forward binary operations from derived
 // classes back to us.
diff --git a/liboctave/MatrixType.h b/liboctave/MatrixType.h
--- a/liboctave/MatrixType.h
+++ b/liboctave/MatrixType.h
@@ -29,6 +29,7 @@
 class SparseComplexMatrix;
 
 class
+OCTAVE_API
 MatrixType
 {
 public:
diff --git a/liboctave/NLEqn.h b/liboctave/NLEqn.h
--- a/liboctave/NLEqn.h
+++ b/liboctave/NLEqn.h
@@ -30,6 +30,7 @@
 #include "NLEqn-opts.h"
 
 class
+OCTAVE_API
 NLEqn : public NLFunc, public NLEqn_options
 {
 public:
diff --git a/liboctave/Quad.h b/liboctave/Quad.h
--- a/liboctave/Quad.h
+++ b/liboctave/Quad.h
@@ -40,11 +40,12 @@
 // variable.
 // Nonzero means an error occurred in the calculation of the integrand
 // function, and the user wants us to quit.
-extern int quad_integration_error;
+extern OCTAVE_API int quad_integration_error;
 
 #include "Quad-opts.h"
 
 class
+OCTAVE_API
 Quad : public Quad_options
 {
  public:
@@ -87,6 +88,7 @@
 };
 
 class
+OCTAVE_API
 DefQuad : public Quad
 {
  public:
@@ -119,6 +121,7 @@
 };
 
 class
+OCTAVE_API
 IndefQuad : public Quad
 {
  public:
diff --git a/liboctave/Range.h b/liboctave/Range.h
--- a/liboctave/Range.h
+++ b/liboctave/Range.h
@@ -28,6 +28,7 @@
 #include "dMatrix.h"
 
 class
+OCTAVE_API
 Range
 {
  public:
@@ -88,8 +89,8 @@
       }
   }
 
-  friend std::ostream& operator << (std::ostream& os, const Range& r);
-  friend std::istream& operator >> (std::istream& is, Range& r);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const Range& r);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is, Range& r);
 
   void print_range (void);
 
@@ -108,7 +109,7 @@
   void clear_cache (void) const { cache.resize (0, 0); }
 };
 
-extern Range operator - (const Range& r);
+extern OCTAVE_API Range operator - (const Range& r);
 
 #endif
 
diff --git a/liboctave/Sparse-op-defs.h b/liboctave/Sparse-op-defs.h
--- a/liboctave/Sparse-op-defs.h
+++ b/liboctave/Sparse-op-defs.h
@@ -26,13 +26,13 @@
 #include "Array-util.h"
 
 #define SPARSE_BIN_OP_DECL(R, OP, X, Y) \
-  extern R OP (const X&, const Y&)
+  extern OCTAVE_API R OP (const X&, const Y&)
 
 #define SPARSE_CMP_OP_DECL(OP, X, Y) \
-  extern SparseBoolMatrix OP (const X&, const Y&)
+  extern OCTAVE_API SparseBoolMatrix OP (const X&, const Y&)
 
 #define SPARSE_BOOL_OP_DECL(OP, X, Y) \
-  extern SparseBoolMatrix OP (const X&, const Y&)
+  extern OCTAVE_API SparseBoolMatrix OP (const X&, const Y&)
 
 // matrix by scalar operations.
 
diff --git a/liboctave/Sparse.h b/liboctave/Sparse.h
--- a/liboctave/Sparse.h
+++ b/liboctave/Sparse.h
@@ -48,7 +48,7 @@
   // The real representation of all Sparse arrays.
   //--------------------------------------------------------------------
 
-  class SparseRep
+  class OCTAVE_API SparseRep
   {
   public:
 
@@ -529,11 +529,11 @@
 assign1 (Sparse<LT>& lhs, const Sparse<RT>& rhs);
 
 #define INSTANTIATE_SPARSE_ASSIGN(LT, RT) \
-  template int assign (Sparse<LT>&, const Sparse<RT>&); \
-  template int assign1 (Sparse<LT>&, const Sparse<RT>&);
+  template OCTAVE_API int assign (Sparse<LT>&, const Sparse<RT>&); \
+  template OCTAVE_API int assign1 (Sparse<LT>&, const Sparse<RT>&);
 
 #define INSTANTIATE_SPARSE(T) \
-  template class Sparse<T>;
+  template class OCTAVE_API Sparse<T>;
 
 #define INSTANTIATE_SPARSE_AND_ASSIGN(T) \
   INSTANTIATE_SPARSE (T); \
diff --git a/liboctave/SparseCmplxCHOL.h b/liboctave/SparseCmplxCHOL.h
--- a/liboctave/SparseCmplxCHOL.h
+++ b/liboctave/SparseCmplxCHOL.h
@@ -28,6 +28,7 @@
 #include "CSparse.h"
 
 class
+OCTAVE_API
 SparseComplexCHOL : 
   public sparse_base_chol <SparseComplexMatrix, Complex, SparseMatrix>
 {
@@ -91,7 +92,7 @@
 	SparseMatrix>:: inverse (); }
 };
 
-SparseComplexMatrix chol2inv (const SparseComplexMatrix& r);
+SparseComplexMatrix OCTAVE_API chol2inv (const SparseComplexMatrix& r);
 
 #endif
 
diff --git a/liboctave/SparseCmplxLU.h b/liboctave/SparseCmplxLU.h
--- a/liboctave/SparseCmplxLU.h
+++ b/liboctave/SparseCmplxLU.h
@@ -28,6 +28,7 @@
 #include "CSparse.h"
 
 class
+OCTAVE_API
 SparseComplexLU 
   : public sparse_base_lu <SparseComplexMatrix, Complex, SparseMatrix, double>
 {
diff --git a/liboctave/SparseCmplxQR.h b/liboctave/SparseCmplxQR.h
--- a/liboctave/SparseCmplxQR.h
+++ b/liboctave/SparseCmplxQR.h
@@ -37,6 +37,7 @@
 #endif
 
 class
+OCTAVE_API
 SparseComplexQR
 {
 protected:
diff --git a/liboctave/SparseQR.h b/liboctave/SparseQR.h
--- a/liboctave/SparseQR.h
+++ b/liboctave/SparseQR.h
@@ -37,6 +37,7 @@
 #endif
 
 class
+OCTAVE_API
 SparseQR
 {
 protected:
diff --git a/liboctave/SparsedbleCHOL.h b/liboctave/SparsedbleCHOL.h
--- a/liboctave/SparsedbleCHOL.h
+++ b/liboctave/SparsedbleCHOL.h
@@ -27,6 +27,7 @@
 #include "dSparse.h"
 
 class
+OCTAVE_API
 SparseCHOL : public sparse_base_chol <SparseMatrix, double, SparseMatrix>
 {
 public:
@@ -79,7 +80,7 @@
        inverse (); }
 };
 
-SparseMatrix chol2inv (const SparseMatrix& r);
+SparseMatrix OCTAVE_API chol2inv (const SparseMatrix& r);
 
 #endif
 
diff --git a/liboctave/SparsedbleLU.h b/liboctave/SparsedbleLU.h
--- a/liboctave/SparsedbleLU.h
+++ b/liboctave/SparsedbleLU.h
@@ -27,6 +27,7 @@
 #include "dSparse.h"
 
 class
+OCTAVE_API
 SparseLU : public sparse_base_lu <SparseMatrix, double, SparseMatrix, double>
 {
 public:
diff --git a/liboctave/boolMatrix.h b/liboctave/boolMatrix.h
--- a/liboctave/boolMatrix.h
+++ b/liboctave/boolMatrix.h
@@ -30,6 +30,7 @@
 #include "mx-op-defs.h"
 
 class
+OCTAVE_API
 boolMatrix : public Array2<bool>
 {
 public:
diff --git a/liboctave/boolNDArray.h b/liboctave/boolNDArray.h
--- a/liboctave/boolNDArray.h
+++ b/liboctave/boolNDArray.h
@@ -33,6 +33,7 @@
 #include "boolMatrix.h"
 
 class
+OCTAVE_API
 boolNDArray : public ArrayN<bool>
 {
 public:
diff --git a/liboctave/boolSparse.h b/liboctave/boolSparse.h
--- a/liboctave/boolSparse.h
+++ b/liboctave/boolSparse.h
@@ -28,6 +28,7 @@
 #include "Sparse-op-defs.h"
 
 class
+OCTAVE_API
 SparseBoolMatrix : public Sparse<bool>
 {
 public:
@@ -108,8 +109,8 @@
 
   // i/o
 
-  friend std::ostream& operator << (std::ostream& os, const SparseBoolMatrix& a);
-  friend std::istream& operator >> (std::istream& is, SparseBoolMatrix& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const SparseBoolMatrix& a);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is, SparseBoolMatrix& a);
 };
 
 SPARSE_SMS_EQNE_OP_DECLS (SparseBoolMatrix, bool)
diff --git a/liboctave/chMatrix.h b/liboctave/chMatrix.h
--- a/liboctave/chMatrix.h
+++ b/liboctave/chMatrix.h
@@ -32,6 +32,7 @@
 #include "str-vec.h"
 
 class
+OCTAVE_API
 charMatrix : public MArray2<char>
 {
 friend class ComplexMatrix;
diff --git a/liboctave/chNDArray.h b/liboctave/chNDArray.h
--- a/liboctave/chNDArray.h
+++ b/liboctave/chNDArray.h
@@ -31,6 +31,7 @@
 #include "mx-op-defs.h"
 
 class
+OCTAVE_API
 charNDArray : public MArrayN<char>
 {
 public:
diff --git a/liboctave/cmd-edit.h b/liboctave/cmd-edit.h
--- a/liboctave/cmd-edit.h
+++ b/liboctave/cmd-edit.h
@@ -31,6 +31,7 @@
 #include "str-vec.h"
 
 class
+OCTAVE_API
 command_editor
 {
 protected:
diff --git a/liboctave/cmd-hist.h b/liboctave/cmd-hist.h
--- a/liboctave/cmd-hist.h
+++ b/liboctave/cmd-hist.h
@@ -29,6 +29,7 @@
 #include "str-vec.h"
 
 class
+OCTAVE_API
 command_history
 {
 protected:
diff --git a/liboctave/dColVector.h b/liboctave/dColVector.h
--- a/liboctave/dColVector.h
+++ b/liboctave/dColVector.h
@@ -29,6 +29,7 @@
 #include "mx-defs.h"
 
 class
+OCTAVE_API
 ColumnVector : public MArray<double>
 {
 public:
@@ -63,8 +64,8 @@
 
   RowVector transpose (void) const;
 
-  friend ColumnVector real (const ComplexColumnVector& a);
-  friend ColumnVector imag (const ComplexColumnVector& a);
+  friend OCTAVE_API ColumnVector real (const ComplexColumnVector& a);
+  friend OCTAVE_API ColumnVector imag (const ComplexColumnVector& a);
 
   // resize is the destructive equivalent for this one
 
@@ -74,11 +75,11 @@
 
   // matrix by column vector -> column vector operations
 
-  friend ColumnVector operator * (const Matrix& a, const ColumnVector& b);
+  friend OCTAVE_API ColumnVector operator * (const Matrix& a, const ColumnVector& b);
 
   // diagonal matrix by column vector -> column vector operations
 
-  friend ColumnVector operator * (const DiagMatrix& a, const ColumnVector& b);
+  friend OCTAVE_API ColumnVector operator * (const DiagMatrix& a, const ColumnVector& b);
 
   // other operations
 
@@ -91,8 +92,8 @@
 
   // i/o
 
-  friend std::ostream& operator << (std::ostream& os, const ColumnVector& a);
-  friend std::istream& operator >> (std::istream& is, ColumnVector& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const ColumnVector& a);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is, ColumnVector& a);
 
 private:
 
@@ -101,8 +102,8 @@
 
 // Publish externally used friend functions.
 
-extern ColumnVector real (const ComplexColumnVector& a);
-extern ColumnVector imag (const ComplexColumnVector& a);
+extern OCTAVE_API ColumnVector real (const ComplexColumnVector& a);
+extern OCTAVE_API ColumnVector imag (const ComplexColumnVector& a);
 
 MARRAY_FORWARD_DEFS (MArray, ColumnVector, double)
 
diff --git a/liboctave/dDiagMatrix.h b/liboctave/dDiagMatrix.h
--- a/liboctave/dDiagMatrix.h
+++ b/liboctave/dDiagMatrix.h
@@ -32,6 +32,7 @@
 #include "mx-defs.h"
 
 class
+OCTAVE_API
 DiagMatrix : public MDiagArray2<double>
 {
 friend class SVD;
diff --git a/liboctave/dMatrix.h b/liboctave/dMatrix.h
--- a/liboctave/dMatrix.h
+++ b/liboctave/dMatrix.h
@@ -32,6 +32,7 @@
 #include "mx-op-defs.h"
 
 class
+OCTAVE_API
 Matrix : public MArray2<double>
 {
 public:
@@ -89,8 +90,8 @@
   Matrix stack (const ColumnVector& a) const;
   Matrix stack (const DiagMatrix& a) const;
 
-  friend Matrix real (const ComplexMatrix& a);
-  friend Matrix imag (const ComplexMatrix& a);
+  friend OCTAVE_API Matrix real (const ComplexMatrix& a);
+  friend OCTAVE_API Matrix imag (const ComplexMatrix& a);
 
   Matrix transpose (void) const { return MArray2<double>::transpose (); }
 
@@ -274,8 +275,8 @@
 
   // i/o
 
-  friend std::ostream& operator << (std::ostream& os, const Matrix& a);
-  friend std::istream& operator >> (std::istream& is, Matrix& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const Matrix& a);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is, Matrix& a);
 
   static double resize_fill_value (void) { return 0; }
 
@@ -286,28 +287,28 @@
 
 // Publish externally used friend functions.
 
-extern Matrix real (const ComplexMatrix& a);
-extern Matrix imag (const ComplexMatrix& a);
+extern OCTAVE_API Matrix real (const ComplexMatrix& a);
+extern OCTAVE_API Matrix imag (const ComplexMatrix& a);
 
 // column vector by row vector -> matrix operations
 
-extern Matrix operator * (const ColumnVector& a, const RowVector& b);
+extern OCTAVE_API Matrix operator * (const ColumnVector& a, const RowVector& b);
 
 // Other functions.
 
-extern Matrix Givens (double, double);
+extern OCTAVE_API Matrix Givens (double, double);
 
-extern Matrix Sylvester (const Matrix&, const Matrix&, const Matrix&);
+extern OCTAVE_API Matrix Sylvester (const Matrix&, const Matrix&, const Matrix&);
 
-extern Matrix operator * (const Matrix& a, const Matrix& b);
+extern OCTAVE_API Matrix operator * (const Matrix& a, const Matrix& b);
 
-extern Matrix min (double d, const Matrix& m);
-extern Matrix min (const Matrix& m, double d);
-extern Matrix min (const Matrix& a, const Matrix& b);
+extern OCTAVE_API Matrix min (double d, const Matrix& m);
+extern OCTAVE_API Matrix min (const Matrix& m, double d);
+extern OCTAVE_API Matrix min (const Matrix& a, const Matrix& b);
 
-extern Matrix max (double d, const Matrix& m);
-extern Matrix max (const Matrix& m, double d);
-extern Matrix max (const Matrix& a, const Matrix& b);
+extern OCTAVE_API Matrix max (double d, const Matrix& m);
+extern OCTAVE_API Matrix max (const Matrix& m, double d);
+extern OCTAVE_API Matrix max (const Matrix& a, const Matrix& b);
 
 MS_CMP_OP_DECLS (Matrix, double)
 MS_BOOL_OP_DECLS (Matrix, double)
diff --git a/liboctave/dNDArray.h b/liboctave/dNDArray.h
--- a/liboctave/dNDArray.h
+++ b/liboctave/dNDArray.h
@@ -32,6 +32,7 @@
 #include "mx-op-defs.h"
 
 class
+OCTAVE_API
 NDArray : public MArrayN<double>
 {
 public:
@@ -102,8 +103,8 @@
   ComplexNDArray fourierNd (void) const;
   ComplexNDArray ifourierNd (void) const;
 
-  friend NDArray real (const ComplexNDArray& a);
-  friend NDArray imag (const ComplexNDArray& a);
+  friend OCTAVE_API NDArray real (const ComplexNDArray& a);
+  friend OCTAVE_API NDArray imag (const ComplexNDArray& a);
 
   Matrix matrix_value (void) const;
 
@@ -118,8 +119,8 @@
 
   // i/o
 
-  friend std::ostream& operator << (std::ostream& os, const NDArray& a);
-  friend std::istream& operator >> (std::istream& is, NDArray& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const NDArray& a);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is, NDArray& a);
 
   static double resize_fill_value (void) { return 0; }
 
@@ -130,16 +131,16 @@
 
 // Publish externally used friend functions.
 
-extern NDArray real (const ComplexNDArray& a);
-extern NDArray imag (const ComplexNDArray& a);
+extern OCTAVE_API NDArray real (const ComplexNDArray& a);
+extern OCTAVE_API NDArray imag (const ComplexNDArray& a);
 
-extern NDArray min (double d, const NDArray& m);
-extern NDArray min (const NDArray& m, double d);
-extern NDArray min (const NDArray& a, const NDArray& b);
+extern OCTAVE_API NDArray min (double d, const NDArray& m);
+extern OCTAVE_API NDArray min (const NDArray& m, double d);
+extern OCTAVE_API NDArray min (const NDArray& a, const NDArray& b);
 
-extern NDArray max (double d, const NDArray& m);
-extern NDArray max (const NDArray& m, double d);
-extern NDArray max (const NDArray& a, const NDArray& b);
+extern OCTAVE_API NDArray max (double d, const NDArray& m);
+extern OCTAVE_API NDArray max (const NDArray& m, double d);
+extern OCTAVE_API NDArray max (const NDArray& a, const NDArray& b);
 
 NDS_CMP_OP_DECLS (NDArray, double)
 NDS_BOOL_OP_DECLS (NDArray, double)
diff --git a/liboctave/dRowVector.h b/liboctave/dRowVector.h
--- a/liboctave/dRowVector.h
+++ b/liboctave/dRowVector.h
@@ -29,6 +29,7 @@
 #include "mx-defs.h"
 
 class
+OCTAVE_API
 RowVector : public MArray<double>
 {
 public:
@@ -63,8 +64,8 @@
 
   ColumnVector transpose (void) const;
 
-  friend RowVector real (const ComplexRowVector& a);
-  friend RowVector imag (const ComplexRowVector& a);
+  friend OCTAVE_API RowVector real (const ComplexRowVector& a);
+  friend OCTAVE_API RowVector imag (const ComplexRowVector& a);
 
   // resize is the destructive equivalent for this one
 
@@ -74,7 +75,7 @@
 
   // row vector by matrix -> row vector
 
-  friend RowVector operator * (const RowVector& a, const Matrix& b);
+  friend OCTAVE_API RowVector operator * (const RowVector& a, const Matrix& b);
 
   // other operations
 
@@ -87,8 +88,8 @@
 
   // i/o
 
-  friend std::ostream& operator << (std::ostream& os, const RowVector& a);
-  friend std::istream& operator >> (std::istream& is, RowVector& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const RowVector& a);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is, RowVector& a);
 
 private:
 
@@ -97,13 +98,13 @@
 
 // row vector by column vector -> scalar
 
-double operator * (const RowVector& a, const ColumnVector& b);
+double OCTAVE_API operator * (const RowVector& a, const ColumnVector& b);
 
-Complex operator * (const RowVector& a, const ComplexColumnVector& b);
+Complex OCTAVE_API operator * (const RowVector& a, const ComplexColumnVector& b);
 
 // other operations
 
-RowVector linspace (double x1, double x2, octave_idx_type n);
+OCTAVE_API RowVector linspace (double x1, double x2, octave_idx_type n);
 
 MARRAY_FORWARD_DEFS (MArray, RowVector, double)
 
diff --git a/liboctave/dSparse.h b/liboctave/dSparse.h
--- a/liboctave/dSparse.h
+++ b/liboctave/dSparse.h
@@ -39,6 +39,7 @@
 class SparseBoolMatrix;
 
 class
+OCTAVE_API
 SparseMatrix : public MSparse<double>
 {
  public:
@@ -101,12 +102,12 @@
   SparseComplexMatrix concat (const SparseComplexMatrix& rb,
 			      const Array<octave_idx_type>& ra_idx);
 
-  friend SparseMatrix real (const SparseComplexMatrix& a);
-  friend SparseMatrix imag (const SparseComplexMatrix& a);
+  friend OCTAVE_API SparseMatrix real (const SparseComplexMatrix& a);
+  friend OCTAVE_API SparseMatrix imag (const SparseComplexMatrix& a);
 
-  friend SparseMatrix atan2 (const double& x, const SparseMatrix& y);
-  friend SparseMatrix atan2 (const SparseMatrix& x, const double& y);
-  friend SparseMatrix atan2 (const SparseMatrix& x, const SparseMatrix& y);
+  friend OCTAVE_API SparseMatrix atan2 (const double& x, const SparseMatrix& y);
+  friend OCTAVE_API SparseMatrix atan2 (const SparseMatrix& x, const double& y);
+  friend OCTAVE_API SparseMatrix atan2 (const SparseMatrix& x, const SparseMatrix& y);
 
   SparseMatrix transpose (void) const 
     { 
@@ -406,31 +407,31 @@
 
   // i/o
 
-  friend std::ostream& operator << (std::ostream& os, const SparseMatrix& a);
-  friend std::istream& operator >> (std::istream& is, SparseMatrix& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const SparseMatrix& a);
+  friend OCTAVE_API std::istream& operator >> (std::istream& is, SparseMatrix& a);
 };
 
 // Publish externally used friend functions.
 
-extern SparseMatrix real (const SparseComplexMatrix& a);
-extern SparseMatrix imag (const SparseComplexMatrix& a);
+extern OCTAVE_API SparseMatrix real (const SparseComplexMatrix& a);
+extern OCTAVE_API SparseMatrix imag (const SparseComplexMatrix& a);
 
 // Other operators.
 
-extern SparseMatrix operator * (const SparseMatrix& a, 
+extern OCTAVE_API SparseMatrix operator * (const SparseMatrix& a, 
 				const SparseMatrix& b);
-extern Matrix operator * (const Matrix& a, 
+extern OCTAVE_API Matrix operator * (const Matrix& a, 
 				const SparseMatrix& b);
-extern Matrix operator * (const SparseMatrix& a, 
+extern OCTAVE_API Matrix operator * (const SparseMatrix& a, 
 				const Matrix& b);
 
-extern SparseMatrix min (double d, const SparseMatrix& m);
-extern SparseMatrix min (const SparseMatrix& m, double d);
-extern SparseMatrix min (const SparseMatrix& a, const SparseMatrix& b);
+extern OCTAVE_API SparseMatrix min (double d, const SparseMatrix& m);
+extern OCTAVE_API SparseMatrix min (const SparseMatrix& m, double d);
+extern OCTAVE_API SparseMatrix min (const SparseMatrix& a, const SparseMatrix& b);
 
-extern SparseMatrix max (double d, const SparseMatrix& m);
-extern SparseMatrix max (const SparseMatrix& m, double d);
-extern SparseMatrix max (const SparseMatrix& a, const SparseMatrix& b);
+extern OCTAVE_API SparseMatrix max (double d, const SparseMatrix& m);
+extern OCTAVE_API SparseMatrix max (const SparseMatrix& m, double d);
+extern OCTAVE_API SparseMatrix max (const SparseMatrix& a, const SparseMatrix& b);
 
 SPARSE_SMS_CMP_OP_DECLS (SparseMatrix, double)
 SPARSE_SMS_BOOL_OP_DECLS (SparseMatrix, double)
diff --git a/liboctave/data-conv.h b/liboctave/data-conv.h
--- a/liboctave/data-conv.h
+++ b/liboctave/data-conv.h
@@ -29,6 +29,7 @@
 #include "mach-info.h"
 
 class
+OCTAVE_API
 oct_data_conv
 {
 public:
@@ -91,28 +92,28 @@
     LS_LONG    = 9
   };
 
-extern void
+extern OCTAVE_API void
 do_double_format_conversion (void *data, int len,
 			     oct_mach_info::float_format from_fmt,
 			     oct_mach_info::float_format to_fmt
 			       = oct_mach_info::native_float_format ());
 
-extern void
+extern OCTAVE_API void
 do_float_format_conversion (void *data, int len,
 			    oct_mach_info::float_format from_fmt,
 			    oct_mach_info::float_format to_fmt
 			      = oct_mach_info::native_float_format ());
 
-extern void
+extern OCTAVE_API void
 do_float_format_conversion (void *data, size_t sz, int len,
 			    oct_mach_info::float_format from_fmt,
 			    oct_mach_info::float_format to_fmt
 			      = oct_mach_info::native_float_format ());
 
-extern void
+extern OCTAVE_API void
 read_doubles (std::istream& is, double *data, save_type type, int len,
 	      bool swap, oct_mach_info::float_format fmt);
-extern void
+extern OCTAVE_API void
 write_doubles (std::ostream& os, const double *data, save_type type, int len);
 
 #endif
diff --git a/liboctave/dbleAEPBAL.h b/liboctave/dbleAEPBAL.h
--- a/liboctave/dbleAEPBAL.h
+++ b/liboctave/dbleAEPBAL.h
@@ -30,6 +30,7 @@
 #include "dMatrix.h"
 
 class
+OCTAVE_API
 AEPBALANCE
 {
 public:
diff --git a/liboctave/dbleCHOL.h b/liboctave/dbleCHOL.h
--- a/liboctave/dbleCHOL.h
+++ b/liboctave/dbleCHOL.h
@@ -29,6 +29,7 @@
 #include "dMatrix.h"
 
 class
+OCTAVE_API
 CHOL
 {
 public:
@@ -54,7 +55,7 @@
   // Compute the inverse of a matrix using the Cholesky factorization.
   Matrix inverse (void) const;
 
-  friend std::ostream& operator << (std::ostream& os, const CHOL& a);
+  friend OCTAVE_API std::ostream& operator << (std::ostream& os, const CHOL& a);
 
 private:
 
@@ -63,7 +64,7 @@
   octave_idx_type init (const Matrix& a);
 };
 
-Matrix chol2inv (const Matrix& r);
+Matrix OCTAVE_API chol2inv (const Matrix& r);
 
 #endif
 
diff --git a/liboctave/dbleDET.h b/liboctave/dbleDET.h
--- a/liboctave/dbleDET.h
+++ b/liboctave/dbleDET.h
@@ -29,6 +29,7 @@
 // FIXME -- we could use templates here; compare with CmplxDET.h
 
 class
+OCTAVE_API
 DET
 {
 friend class Matrix;
diff --git a/liboctave/dbleHESS.h b/liboctave/dbleHESS.h
--- a/liboctave/dbleHESS.h
+++ b/liboctave/dbleHESS.h
@@ -29,6 +29,7 @@
 #include "dMatrix.h"
 
 class
+OCTAVE_API
 HESS
 {
 public:
diff --git a/liboctave/dbleLU.h b/liboctave/dbleLU.h
--- a/liboctave/dbleLU.h
+++ b/liboctave/dbleLU.h
@@ -28,6 +28,7 @@
 #include "dMatrix.h"
 
 class
+OCTAVE_API
 LU : public base_lu <Matrix, double, Matrix, double>
 {
 public:
diff --git a/liboctave/dbleQR.h b/liboctave/dbleQR.h
--- a/liboctave/dbleQR.h
+++ b/liboctave/dbleQR.h
@@ -29,6 +29,7 @@
 #include "dMatrix.h"
 
 class
+OCTAVE_API
 QR
 {
 public:
diff --git a/liboctave/dbleQRP.h b/liboctave/dbleQRP.h
--- a/liboctave/dbleQRP.h
+++ b/liboctave/dbleQRP.h
@@ -29,6 +29,7 @@
 #include "dbleQR.h"
 
 class
+OCTAVE_API
 QRP : public QR
 {
 public:
diff --git a/liboctave/dbleSCHUR.h b/liboctave/dbleSCHUR.h
--- a/liboctave/dbleSCHUR.h
+++ b/liboctave/dbleSCHUR.h
@@ -30,6 +30,7 @@
 #include "dMatrix.h"
 
 class
+OCTAVE_API
 SCHUR
 {
 public:
diff --git a/liboctave/dbleSVD.h b/liboctave/dbleSVD.h
--- a/liboctave/dbleSVD.h
+++ b/liboctave/dbleSVD.h
@@ -30,6 +30,7 @@
 #include "dMatrix.h"
 
 class
+OCTAVE_API
 SVD
 {
 public:
diff --git a/liboctave/dir-ops.h b/liboctave/dir-ops.h
--- a/liboctave/dir-ops.h
+++ b/liboctave/dir-ops.h
@@ -29,6 +29,7 @@
 #include "str-vec.h"
 
 class
+OCTAVE_API
 dir_entry
 {
 public:
diff --git a/liboctave/file-ops.h b/liboctave/file-ops.h
--- a/liboctave/file-ops.h
+++ b/liboctave/file-ops.h
@@ -33,6 +33,7 @@
 #include "str-vec.h"
 
 struct
+OCTAVE_API
 file_ops
 {
   static int mkdir (const std::string&, mode_t);
diff --git a/liboctave/file-stat.h b/liboctave/file-stat.h
--- a/liboctave/file-stat.h
+++ b/liboctave/file-stat.h
@@ -33,6 +33,7 @@
 #endif
 
 class
+OCTAVE_API
 file_stat
 {
 public:
diff --git a/liboctave/glob-match.h b/liboctave/glob-match.h
--- a/liboctave/glob-match.h
+++ b/liboctave/glob-match.h
@@ -30,6 +30,7 @@
 #include "str-vec.h"
 
 class
+OCTAVE_API
 glob_match
 {
 public:
diff --git a/liboctave/idx-vector.h b/liboctave/idx-vector.h
--- a/liboctave/idx-vector.h
+++ b/liboctave/idx-vector.h
@@ -36,11 +36,13 @@
 class Range;
 
 class
+OCTAVE_API
 idx_vector
 {
 private:
 
   class
+  OCTAVE_API
   idx_vector_rep
   {
   public:
diff --git a/liboctave/int16NDArray.cc b/liboctave/int16NDArray.cc
--- a/liboctave/int16NDArray.cc
+++ b/liboctave/int16NDArray.cc
@@ -30,13 +30,13 @@
 
 #include "intNDArray.cc"
 
-template class intNDArray<octave_int16>;
+template class OCTAVE_API intNDArray<octave_int16>;
 
-template
+template OCTAVE_API
 std::ostream&
 operator << (std::ostream& os, const intNDArray<octave_int16>& a);
 
-template
+template OCTAVE_API
 std::istream&
 operator >> (std::istream& is, intNDArray<octave_int16>& a);
 
diff --git a/liboctave/int32NDArray.cc b/liboctave/int32NDArray.cc
--- a/liboctave/int32NDArray.cc
+++ b/liboctave/int32NDArray.cc
@@ -30,13 +30,13 @@
 
 #include "intNDArray.cc"
 
-template class intNDArray<octave_int32>;
+template class OCTAVE_API intNDArray<octave_int32>;
 
-template
+template OCTAVE_API
 std::ostream&
 operator << (std::ostream& os, const intNDArray<octave_int32>& a);
 
-template
+template OCTAVE_API
 std::istream&
 operator >> (std::istream& is, intNDArray<octave_int32>& a);
 
diff --git a/liboctave/int64NDArray.cc b/liboctave/int64NDArray.cc
--- a/liboctave/int64NDArray.cc
+++ b/liboctave/int64NDArray.cc
@@ -30,13 +30,13 @@
 
 #include "intNDArray.cc"
 
-template class intNDArray<octave_int64>;
+template class OCTAVE_API intNDArray<octave_int64>;
 
-template
+template OCTAVE_API
 std::ostream&
 operator << (std::ostream& os, const intNDArray<octave_int64>& a);
 
-template
+template OCTAVE_API
 std::istream&
 operator >> (std::istream& is, intNDArray<octave_int64>& a);
 
diff --git a/liboctave/int8NDArray.cc b/liboctave/int8NDArray.cc
--- a/liboctave/int8NDArray.cc
+++ b/liboctave/int8NDArray.cc
@@ -30,13 +30,13 @@
 
 #include "intNDArray.cc"
 
-template class intNDArray<octave_int8>;
+template class OCTAVE_API intNDArray<octave_int8>;
 
-template
+template OCTAVE_API
 std::ostream&
 operator << (std::ostream& os, const intNDArray<octave_int8>& a);
 
-template
+template OCTAVE_API
 std::istream&
 operator >> (std::istream& is, intNDArray<octave_int8>& a);
 
diff --git a/liboctave/lo-cutils.c b/liboctave/lo-cutils.c
--- a/liboctave/lo-cutils.c
+++ b/liboctave/lo-cutils.c
@@ -53,14 +53,14 @@
 
 #include "syswait.h"
 
-void
+OCTAVE_API void
 octave_qsort (void *base, size_t n, size_t size,
 	      int (*cmp) (const void *, const void *))
 {
   qsort (base, n, size, cmp);
 }
 
-char *
+OCTAVE_API char *
 oct_strptime (const char *buf, const char *format, struct tm *tm)
 {
   return (char *) strptime (buf, format, tm);
@@ -92,7 +92,7 @@
 
 #endif
 
-int
+OCTAVE_API int
 octave_gethostname (char *name, int namelen)
 {
   return gethostname (name, namelen);
@@ -102,14 +102,14 @@
 #include <windows.h>
 
 /* Need this since in C++ can't cast from int(*)() to void* */
-void *
+OCTAVE_API void *
 octave_w32_library_search (HINSTANCE handle, const char * name)
 {
   return (GetProcAddress (handle, name));
 }
 #endif
 
-pid_t
+OCTAVE_API pid_t
 octave_waitpid (pid_t pid, int *status, int options)
 {
   return WAITPID (pid, status, options);
diff --git a/liboctave/lo-ieee.h b/liboctave/lo-ieee.h
--- a/liboctave/lo-ieee.h
+++ b/liboctave/lo-ieee.h
@@ -29,19 +29,19 @@
 #endif
 
 /*  Octave's idea of infinity.  */
-extern double octave_Inf;
+extern OCTAVE_API double octave_Inf;
 
 /* Octave's idea of a missing value.  */
-extern double octave_NA;
+extern OCTAVE_API double octave_NA;
 
 /* Octave's idea of not a number.  */
-extern double octave_NaN;
+extern OCTAVE_API double octave_NaN;
 
 /* FIXME -- this code assumes that a double has twice the
    number of bits as an int */
 
-extern int lo_ieee_hw;
-extern int lo_ieee_lw;
+extern OCTAVE_API int lo_ieee_hw;
+extern OCTAVE_API int lo_ieee_lw;
 
 typedef union
 {
@@ -52,25 +52,25 @@
 #define LO_IEEE_NA_HW 0x7ff00000
 #define LO_IEEE_NA_LW 1954
 
-extern void octave_ieee_init (void);
+extern OCTAVE_API void octave_ieee_init (void);
 
 #if defined (SCO)
 extern int isnan (double);
 extern int isinf (double);
 #endif
 
-extern int lo_ieee_isnan (double x);
-extern int lo_ieee_finite (double x);
-extern int lo_ieee_isinf (double x);
+extern OCTAVE_API int lo_ieee_isnan (double x);
+extern OCTAVE_API int lo_ieee_finite (double x);
+extern OCTAVE_API int lo_ieee_isinf (double x);
 
-extern int lo_ieee_is_NA (double);
-extern int lo_ieee_is_NaN_or_NA (double) GCC_ATTR_DEPRECATED;
+extern OCTAVE_API int lo_ieee_is_NA (double);
+extern OCTAVE_API int lo_ieee_is_NaN_or_NA (double) GCC_ATTR_DEPRECATED;
 
-extern double lo_ieee_inf_value (void);
-extern double lo_ieee_na_value (void);
-extern double lo_ieee_nan_value (void);
+extern OCTAVE_API double lo_ieee_inf_value (void);
+extern OCTAVE_API double lo_ieee_na_value (void);
+extern OCTAVE_API double lo_ieee_nan_value (void);
 
-extern int lo_ieee_signbit (double);
+extern OCTAVE_API int lo_ieee_signbit (double);
 
 #ifdef	__cplusplus
 }
diff --git a/liboctave/lo-mappers.h b/liboctave/lo-mappers.h
--- a/liboctave/lo-mappers.h
+++ b/liboctave/lo-mappers.h
@@ -26,48 +26,48 @@
 
 #include "oct-cmplx.h"
 
-extern double arg (double x);
-extern double conj (double x);
-extern double fix (double x);
-extern double imag (double x);
-extern double real (double x);
-extern double xround (double x);
-extern double signum (double x);
-extern double xlog2 (double x); 
-extern double xexp2 (double x);
+extern OCTAVE_API double arg (double x);
+extern OCTAVE_API double conj (double x);
+extern OCTAVE_API double fix (double x);
+extern OCTAVE_API double imag (double x);
+extern OCTAVE_API double real (double x);
+extern OCTAVE_API double xround (double x);
+extern OCTAVE_API double signum (double x);
+extern OCTAVE_API double xlog2 (double x); 
+extern OCTAVE_API double xexp2 (double x);
 
-extern bool xisnan (double x);
-extern bool xfinite (double x);
-extern bool xisinf (double x);
+extern OCTAVE_API bool xisnan (double x);
+extern OCTAVE_API bool xfinite (double x);
+extern OCTAVE_API bool xisinf (double x);
 
-extern bool octave_is_NA (double x);
-extern bool octave_is_NaN_or_NA (double x) GCC_ATTR_DEPRECATED;
+extern OCTAVE_API bool octave_is_NA (double x);
+extern OCTAVE_API bool octave_is_NaN_or_NA (double x) GCC_ATTR_DEPRECATED;
 
-extern double xmin (double x, double y);
-extern double xmax (double x, double y);
+extern OCTAVE_API double xmin (double x, double y);
+extern OCTAVE_API double xmax (double x, double y);
 
-extern Complex acos (const Complex& x);
-extern Complex acosh (const Complex& x);
-extern Complex asin (const Complex& x);
-extern Complex asinh (const Complex& x);
-extern Complex atan (const Complex& x);
-extern Complex atanh (const Complex& x);
+extern OCTAVE_API Complex acos (const Complex& x);
+extern OCTAVE_API Complex acosh (const Complex& x);
+extern OCTAVE_API Complex asin (const Complex& x);
+extern OCTAVE_API Complex asinh (const Complex& x);
+extern OCTAVE_API Complex atan (const Complex& x);
+extern OCTAVE_API Complex atanh (const Complex& x);
 
-extern Complex ceil (const Complex& x);
-extern Complex fix (const Complex& x);
-extern Complex floor (const Complex& x);
-extern Complex xround (const Complex& x);
-extern Complex signum (const Complex& x);
+extern OCTAVE_API Complex ceil (const Complex& x);
+extern OCTAVE_API Complex fix (const Complex& x);
+extern OCTAVE_API Complex floor (const Complex& x);
+extern OCTAVE_API Complex xround (const Complex& x);
+extern OCTAVE_API Complex signum (const Complex& x);
 
-extern bool xisnan (const Complex& x);
-extern bool xfinite (const Complex& x);
-extern bool xisinf (const Complex& x);
+extern OCTAVE_API bool xisnan (const Complex& x);
+extern OCTAVE_API bool xfinite (const Complex& x);
+extern OCTAVE_API bool xisinf (const Complex& x);
 
-extern bool octave_is_NA (const Complex& x);
-extern bool octave_is_NaN_or_NA (const Complex& x);
+extern OCTAVE_API bool octave_is_NA (const Complex& x);
+extern OCTAVE_API bool octave_is_NaN_or_NA (const Complex& x);
 
-extern Complex xmin (const Complex& x, const Complex& y);
-extern Complex xmax (const Complex& x, const Complex& y);
+extern OCTAVE_API Complex xmin (const Complex& x, const Complex& y);
+extern OCTAVE_API Complex xmax (const Complex& x, const Complex& y);
 
 #endif
 
diff --git a/liboctave/lo-specfun.h b/liboctave/lo-specfun.h
--- a/liboctave/lo-specfun.h
+++ b/liboctave/lo-specfun.h
@@ -38,256 +38,256 @@
 class Range;
 
 #if !defined (HAVE_ACOSH)
-extern double acosh (double);
+extern OCTAVE_API double acosh (double);
 #endif
 
 #if !defined (HAVE_ASINH)
-extern double asinh (double);
+extern OCTAVE_API double asinh (double);
 #endif
 
 #if !defined (HAVE_ATANH)
-extern double atanh (double);
+extern OCTAVE_API double atanh (double);
 #endif
 
 #if !defined (HAVE_ERF)
-extern double erf (double);
+extern OCTAVE_API double erf (double);
 #endif
 
 #if !defined (HAVE_ERFC)
-extern double erfc (double);
+extern OCTAVE_API double erfc (double);
 #endif
 
-extern double xgamma (double x);
-extern double xlgamma (double x);
+extern OCTAVE_API double xgamma (double x);
+extern OCTAVE_API double xlgamma (double x);
 
-extern Complex
+extern OCTAVE_API Complex
 besselj (double alpha, const Complex& x, bool scaled, octave_idx_type& ierr);
 
-extern Complex
+extern OCTAVE_API Complex
 bessely (double alpha, const Complex& x, bool scaled, octave_idx_type& ierr);
 
-extern Complex
+extern OCTAVE_API Complex
 besseli (double alpha, const Complex& x, bool scaled, octave_idx_type& ierr);
 
-extern Complex
+extern OCTAVE_API Complex
 besselk (double alpha, const Complex& x, bool scaled, octave_idx_type& ierr);
 
-extern Complex
+extern OCTAVE_API Complex
 besselh1 (double alpha, const Complex& x, bool scaled, octave_idx_type& ierr);
 
-extern Complex
+extern OCTAVE_API Complex
 besselh2 (double alpha, const Complex& x, bool scaled, octave_idx_type& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselj (double alpha, const ComplexMatrix& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 bessely (double alpha, const ComplexMatrix& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besseli (double alpha, const ComplexMatrix& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselk (double alpha, const ComplexMatrix& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselh1 (double alpha, const ComplexMatrix& x, bool scaled,
 	  Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselh2 (double alpha, const ComplexMatrix& x, bool scaled,
 	  Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselj (const Matrix& alpha, const Complex& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 bessely (const Matrix& alpha, const Complex& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besseli (const Matrix& alpha, const Complex& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselk (const Matrix& alpha, const Complex& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselh1 (const Matrix& alpha, const Complex& x, bool scaled,
 	  Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselh2 (const Matrix& alpha, const Complex& x, bool scaled,
 	  Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselj (const Matrix& alpha, const ComplexMatrix& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 bessely (const Matrix& alpha, const ComplexMatrix& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besseli (const Matrix& alpha, const ComplexMatrix& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselk (const Matrix& alpha, const ComplexMatrix& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselh1 (const Matrix& alpha, const ComplexMatrix& x, bool scaled,
 	  Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselh2 (const Matrix& alpha, const ComplexMatrix& x, bool scaled,
 	  Array2<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselj (double alpha, const ComplexNDArray& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 bessely (double alpha, const ComplexNDArray& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besseli (double alpha, const ComplexNDArray& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselk (double alpha, const ComplexNDArray& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselh1 (double alpha, const ComplexNDArray& x, bool scaled,
 	  ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselh2 (double alpha, const ComplexNDArray& x, bool scaled,
 	  ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselj (const NDArray& alpha, const Complex& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 bessely (const NDArray& alpha, const Complex& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besseli (const NDArray& alpha, const Complex& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselk (const NDArray& alpha, const Complex& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselh1 (const NDArray& alpha, const Complex& x, bool scaled,
 	  ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselh2 (const NDArray& alpha, const Complex& x, bool scaled,
 	  ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselj (const NDArray& alpha, const ComplexNDArray& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 bessely (const NDArray& alpha, const ComplexNDArray& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besseli (const NDArray& alpha, const ComplexNDArray& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselk (const NDArray& alpha, const ComplexNDArray& x, bool scaled,
 	 ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselh1 (const NDArray& alpha, const ComplexNDArray& x, bool scaled,
 	  ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 besselh2 (const NDArray& alpha, const ComplexNDArray& x, bool scaled,
 	  ArrayN<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselj (const RowVector& alpha, const ComplexColumnVector& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 bessely (const RowVector& alpha, const ComplexColumnVector& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besseli (const RowVector& alpha, const ComplexColumnVector& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselk (const RowVector& alpha, const ComplexColumnVector& x, bool scaled,
 	 Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselh1 (const RowVector& alpha, const ComplexColumnVector& x, bool scaled,
 	  Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 besselh2 (const RowVector& alpha, const ComplexColumnVector& x, bool scaled,
 	  Array2<octave_idx_type>& ierr);
 
-extern Complex airy (const Complex& z, bool deriv, bool scaled, octave_idx_type& ierr);
-extern Complex biry (const Complex& z, bool deriv, bool scaled, octave_idx_type& ierr);
+extern OCTAVE_API Complex airy (const Complex& z, bool deriv, bool scaled, octave_idx_type& ierr);
+extern OCTAVE_API Complex biry (const Complex& z, bool deriv, bool scaled, octave_idx_type& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 airy (const ComplexMatrix& z, bool deriv, bool scaled, Array2<octave_idx_type>& ierr);
 
-extern ComplexMatrix
+extern OCTAVE_API ComplexMatrix
 biry (const ComplexMatrix& z, bool deriv, bool scaled, Array2<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 airy (const ComplexNDArray& z, bool deriv, bool scaled, ArrayN<octave_idx_type>& ierr);
 
-extern ComplexNDArray
+extern OCTAVE_API ComplexNDArray
 biry (const ComplexNDArray& z, bool deriv, bool scaled, ArrayN<octave_idx_type>& ierr);
 
-extern double betainc (double x, double a, double b);
-extern Matrix betainc (double x, double a, const Matrix& b);
-extern Matrix betainc (double x, const Matrix& a, double b);
-extern Matrix betainc (double x, const Matrix& a, const Matrix& b);
+extern OCTAVE_API double betainc (double x, double a, double b);
+extern OCTAVE_API Matrix betainc (double x, double a, const Matrix& b);
+extern OCTAVE_API Matrix betainc (double x, const Matrix& a, double b);
+extern OCTAVE_API Matrix betainc (double x, const Matrix& a, const Matrix& b);
 
-extern NDArray betainc (double x, double a, const NDArray& b);
-extern NDArray betainc (double x, const NDArray& a, double b);
-extern NDArray betainc (double x, const NDArray& a, const NDArray& b);
+extern OCTAVE_API NDArray betainc (double x, double a, const NDArray& b);
+extern OCTAVE_API NDArray betainc (double x, const NDArray& a, double b);
+extern OCTAVE_API NDArray betainc (double x, const NDArray& a, const NDArray& b);
 
-extern Matrix betainc (const Matrix& x, double a, double b);
-extern Matrix betainc (const Matrix& x, double a, const Matrix& b);
-extern Matrix betainc (const Matrix& x, const Matrix& a, double b);
-extern Matrix betainc (const Matrix& x, const Matrix& a, const Matrix& b);
+extern OCTAVE_API Matrix betainc (const Matrix& x, double a, double b);
+extern OCTAVE_API Matrix betainc (const Matrix& x, double a, const Matrix& b);
+extern OCTAVE_API Matrix betainc (const Matrix& x, const Matrix& a, double b);
+extern OCTAVE_API Matrix betainc (const Matrix& x, const Matrix& a, const Matrix& b);
 
-extern NDArray betainc (const NDArray& x, double a, double b);
-extern NDArray betainc (const NDArray& x, double a, const NDArray& b);
-extern NDArray betainc (const NDArray& x, const NDArray& a, double b);
-extern NDArray betainc (const NDArray& x, const NDArray& a, const NDArray& b);
+extern OCTAVE_API NDArray betainc (const NDArray& x, double a, double b);
+extern OCTAVE_API NDArray betainc (const NDArray& x, double a, const NDArray& b);
+extern OCTAVE_API NDArray betainc (const NDArray& x, const NDArray& a, double b);
+extern OCTAVE_API NDArray betainc (const NDArray& x, const NDArray& a, const NDArray& b);
 
-extern double gammainc (double x, double a, bool& err);
-extern Matrix gammainc (double x, const Matrix& a);
-extern Matrix gammainc (const Matrix& x, double a);
-extern Matrix gammainc (const Matrix& x, const Matrix& a);
+extern OCTAVE_API double gammainc (double x, double a, bool& err);
+extern OCTAVE_API Matrix gammainc (double x, const Matrix& a);
+extern OCTAVE_API Matrix gammainc (const Matrix& x, double a);
+extern OCTAVE_API Matrix gammainc (const Matrix& x, const Matrix& a);
 
-extern NDArray gammainc (double x, const NDArray& a);
-extern NDArray gammainc (const NDArray& x, double a);
-extern NDArray gammainc (const NDArray& x, const NDArray& a);
+extern OCTAVE_API NDArray gammainc (double x, const NDArray& a);
+extern OCTAVE_API NDArray gammainc (const NDArray& x, double a);
+extern OCTAVE_API NDArray gammainc (const NDArray& x, const NDArray& a);
 
 inline double gammainc (double x, double a)
 {
diff --git a/liboctave/lo-utils.h b/liboctave/lo-utils.h
--- a/liboctave/lo-utils.h
+++ b/liboctave/lo-utils.h
@@ -33,41 +33,43 @@
 #include "oct-types.h"
 #include "syswait.h"
 
-extern octave_idx_type NINTbig (double x);
-extern int NINT (double x);
-extern double D_NINT (double x);
+extern OCTAVE_API octave_idx_type NINTbig (double x);
+extern OCTAVE_API int NINT (double x);
+extern OCTAVE_API double D_NINT (double x);
 
-extern char *strsave (const char *);
+extern OCTAVE_API char *strsave (const char *);
 
-extern void octave_putenv (const std::string&, const std::string&);
+extern OCTAVE_API void octave_putenv (const std::string&, const std::string&);
 
-extern std::string octave_fgets (std::FILE *);
-extern std::string octave_fgetl (std::FILE *);
+extern OCTAVE_API std::string octave_fgets (std::FILE *);
+extern OCTAVE_API std::string octave_fgetl (std::FILE *);
 
-extern std::string octave_fgets (std::FILE *, bool& eof);
-extern std::string octave_fgetl (std::FILE *, bool& eof);
+extern OCTAVE_API std::string octave_fgets (std::FILE *, bool& eof);
+extern OCTAVE_API std::string octave_fgetl (std::FILE *, bool& eof);
 
-extern "C" int octave_gethostname (char *, int);
+extern "C" OCTAVE_API int octave_gethostname (char *, int);
 
-extern "C" void octave_qsort (void *base, size_t n, size_t size,
+extern "C" OCTAVE_API void octave_qsort (void *base, size_t n, size_t size,
 			      int (*cmp) (const void *, const void *));
 
-extern "C" char *oct_strptime (const char *buf, const char *format,
+extern "C" OCTAVE_API char *oct_strptime (const char *buf, const char *format,
 			       struct tm *tm);
 
-extern double octave_read_double (std::istream& is);
-extern Complex octave_read_complex (std::istream& is);
+extern OCTAVE_API double octave_read_double (std::istream& is);
+extern OCTAVE_API Complex octave_read_complex (std::istream& is);
 
-extern void octave_write_double (std::ostream& os, double dval);
-extern void octave_write_complex (std::ostream& os, const Complex& cval);
+extern OCTAVE_API void octave_write_double (std::ostream& os, double dval);
+extern OCTAVE_API void octave_write_complex (std::ostream& os, const Complex& cval);
 
 #ifdef HAVE_LOADLIBRARY_API
 #include <windows.h>
-extern "C" void * octave_w32_library_search (HINSTANCE handle, const char *name);
+extern "C" OCTAVE_API void * octave_w32_library_search (HINSTANCE handle, const char *name);
+#undef min
+#undef max
 #endif
 #endif
 
-extern "C" pid_t octave_waitpid (pid_t pid, int *status, int options);
+extern "C" OCTAVE_API pid_t octave_waitpid (pid_t pid, int *status, int options);
 
 /*
 ;;; Local Variables: ***
diff --git a/liboctave/mach-info.h b/liboctave/mach-info.h
--- a/liboctave/mach-info.h
+++ b/liboctave/mach-info.h
@@ -27,6 +27,7 @@
 #include <string>
 
 class
+OCTAVE_API
 oct_mach_info
 {
 protected:
diff --git a/liboctave/mx-op-defs.h b/liboctave/mx-op-defs.h
--- a/liboctave/mx-op-defs.h
+++ b/liboctave/mx-op-defs.h
@@ -27,22 +27,22 @@
 #include "mx-inlines.cc"
 
 #define BIN_OP_DECL(R, OP, X, Y) \
-  extern R OP (const X&, const Y&)
+  extern OCTAVE_API R OP (const X&, const Y&)
 
 class boolMatrix;
 class boolNDArray;
 
 #define CMP_OP_DECL(OP, X, Y) \
-  extern boolMatrix OP (const X&, const Y&)
+  extern OCTAVE_API boolMatrix OP (const X&, const Y&)
 
 #define NDCMP_OP_DECL(OP, X, Y) \
-  extern boolNDArray OP (const X&, const Y&)
+  extern OCTAVE_API boolNDArray OP (const X&, const Y&)
 
 #define BOOL_OP_DECL(OP, X, Y) \
-  extern boolMatrix OP (const X&, const Y&)
+  extern OCTAVE_API boolMatrix OP (const X&, const Y&)
 
 #define NDBOOL_OP_DECL(OP, X, Y) \
-  extern boolNDArray OP (const X&, const Y&)
+  extern OCTAVE_API boolNDArray OP (const X&, const Y&)
 
 // vector by scalar operations.
 
diff --git a/liboctave/oct-alloc.h b/liboctave/oct-alloc.h
--- a/liboctave/oct-alloc.h
+++ b/liboctave/oct-alloc.h
@@ -25,6 +25,7 @@
 #define octave_oct_alloc_h 1
 
 class
+OCTAVE_API
 octave_allocator
 {
 public:
diff --git a/liboctave/oct-env.h b/liboctave/oct-env.h
--- a/liboctave/oct-env.h
+++ b/liboctave/oct-env.h
@@ -27,6 +27,7 @@
 #include <string>
 
 class
+OCTAVE_API
 octave_env
 {
 protected:
diff --git a/liboctave/oct-group.h b/liboctave/oct-group.h
--- a/liboctave/oct-group.h
+++ b/liboctave/oct-group.h
@@ -33,6 +33,7 @@
 #include "str-vec.h"
 
 class
+OCTAVE_API
 octave_group
 {
 public:
diff --git a/liboctave/oct-inttypes.cc b/liboctave/oct-inttypes.cc
--- a/liboctave/oct-inttypes.cc
+++ b/liboctave/oct-inttypes.cc
@@ -28,7 +28,7 @@
 #include "oct-inttypes.h"
 
 #define INSTANTIATE_INT_DOUBLE_BIN_OP(T, OP) \
-  template octave_int<T> operator OP (const octave_int<T>&, double)
+  template OCTAVE_API octave_int<T> operator OP (const octave_int<T>&, double)
 
 #define INSTANTIATE_INT_DOUBLE_BIN_OPS(T) \
   INSTANTIATE_INT_DOUBLE_BIN_OP (T, +); \
@@ -37,7 +37,7 @@
   INSTANTIATE_INT_DOUBLE_BIN_OP (T, /)
 
 #define INSTANTIATE_DOUBLE_INT_BIN_OP(T, OP) \
-  template octave_int<T> operator OP (double, const octave_int<T>&)
+  template OCTAVE_API octave_int<T> operator OP (double, const octave_int<T>&)
 
 #define INSTANTIATE_DOUBLE_INT_BIN_OPS(T) \
   INSTANTIATE_DOUBLE_INT_BIN_OP (T, +); \
@@ -46,7 +46,7 @@
   INSTANTIATE_DOUBLE_INT_BIN_OP (T, /)
 
 #define INSTANTIATE_INT_DOUBLE_CMP_OP(T, OP) \
-  template bool operator OP (const octave_int<T>&, const double&)
+  template OCTAVE_API bool operator OP (const octave_int<T>&, const double&)
 
 #define INSTANTIATE_INT_DOUBLE_CMP_OPS(T) \
   INSTANTIATE_INT_DOUBLE_CMP_OP (T, <); \
@@ -57,7 +57,7 @@
   INSTANTIATE_INT_DOUBLE_CMP_OP (T, !=)
 
 #define INSTANTIATE_DOUBLE_INT_CMP_OP(T, OP) \
-  template bool operator OP (const double&, const octave_int<T>&)
+  template OCTAVE_API bool operator OP (const double&, const octave_int<T>&)
 
 #define INSTANTIATE_DOUBLE_INT_CMP_OPS(T) \
   INSTANTIATE_DOUBLE_INT_CMP_OP (T, <); \
@@ -68,7 +68,7 @@
   INSTANTIATE_DOUBLE_INT_CMP_OP (T, !=)
 
 #define INSTANTIATE_INT_BITCMP_OP(T, OP) \
-  template octave_int<T> \
+  template OCTAVE_API octave_int<T> \
   operator OP (const octave_int<T>&, const octave_int<T>&)
 
 #define INSTANTIATE_INT_BITCMP_OPS(T) \
@@ -77,13 +77,13 @@
   INSTANTIATE_INT_BITCMP_OP (T, ^)
 
 #define INSTANTIATE_INTTYPE(T) \
-  template class octave_int<T>; \
-  template octave_int<T> pow (const octave_int<T>&, const octave_int<T>&); \
-  template octave_int<T> pow (double, const octave_int<T>&); \
-  template octave_int<T> pow (const octave_int<T>&, double b); \
-  template std::ostream& operator << (std::ostream&, const octave_int<T>&); \
-  template std::istream& operator >> (std::istream&, octave_int<T>&); \
-  template octave_int<T> \
+  template class OCTAVE_API octave_int<T>; \
+  template OCTAVE_API octave_int<T> pow (const octave_int<T>&, const octave_int<T>&); \
+  template OCTAVE_API octave_int<T> pow (double, const octave_int<T>&); \
+  template OCTAVE_API octave_int<T> pow (const octave_int<T>&, double b); \
+  template OCTAVE_API std::ostream& operator << (std::ostream&, const octave_int<T>&); \
+  template OCTAVE_API std::istream& operator >> (std::istream&, octave_int<T>&); \
+  template OCTAVE_API octave_int<T> \
   bitshift (const octave_int<T>&, int, const octave_int<T>&); \
   INSTANTIATE_INT_DOUBLE_BIN_OPS (T); \
   INSTANTIATE_DOUBLE_INT_BIN_OPS (T); \
@@ -184,7 +184,7 @@
 INSTANTIATE_INTTYPE_BIN_OPS (uint64_t, uint64_t);
 
 #define INSTANTIATE_INTTYPE_SHIFT_OP(T, OP) \
-  template octave_int<T> operator OP (const octave_int<T>&, const int&)
+  template OCTAVE_API octave_int<T> operator OP (const octave_int<T>&, const int&)
 
 #define INSTANTIATE_INTTYPE_SHIFT_OPS(T) \
   INSTANTIATE_INTTYPE_SHIFT_OP (T, <<); \
@@ -200,7 +200,7 @@
 INSTANTIATE_INTTYPE_SHIFT_OPS (uint64_t);
 
 #define INSTANTIATE_OCTAVE_INT_CMP_OP(OP, T1, T2) \
-  template bool operator OP (const octave_int<T1>&, const octave_int<T2>&)
+  template OCTAVE_API bool operator OP (const octave_int<T1>&, const octave_int<T2>&)
 
 #define INSTANTIATE_OCTAVE_INT_CMP_OPS(T1, T2) \
   INSTANTIATE_OCTAVE_INT_CMP_OP (<, T1, T2); \
diff --git a/liboctave/oct-inttypes.h b/liboctave/oct-inttypes.h
--- a/liboctave/oct-inttypes.h
+++ b/liboctave/oct-inttypes.h
@@ -553,7 +553,7 @@
 // type and compare).
 
 #define OCTAVE_US_TYPE1_CMP_OP_DECL(OP, LTZ_VAL, UT, ST) \
-  bool operator OP (const octave_int<UT>& lhs, const octave_int<ST>& rhs);
+  bool OCTAVE_API operator OP (const octave_int<UT>& lhs, const octave_int<ST>& rhs);
 
 #define OCTAVE_US_TYPE1_CMP_OP_DECLS(UT, ST) \
   OCTAVE_US_TYPE1_CMP_OP_DECL (<, false, UT, ST) \
@@ -564,7 +564,7 @@
   OCTAVE_US_TYPE1_CMP_OP_DECL (!=, true, UT, ST)
 
 #define OCTAVE_SU_TYPE1_CMP_OP_DECL(OP, LTZ_VAL, ST, UT) \
-  bool operator OP (const octave_int<ST>& lhs, const octave_int<UT>& rhs);
+  bool OCTAVE_API operator OP (const octave_int<ST>& lhs, const octave_int<UT>& rhs);
 
 #define OCTAVE_SU_TYPE1_CMP_OP_DECLS(ST, UT) \
   OCTAVE_SU_TYPE1_CMP_OP_DECL (<, true, ST, UT) \
@@ -592,7 +592,7 @@
 // compare if the signed value is positive).
 
 #define OCTAVE_US_TYPE2_CMP_OP_DECL(OP, LTZ_VAL, UT, ST) \
-  bool operator OP (const octave_int<UT>& lhs, const octave_int<ST>& rhs);
+  bool OCTAVE_API operator OP (const octave_int<UT>& lhs, const octave_int<ST>& rhs);
 
 #define OCTAVE_US_TYPE2_CMP_OP_DECLS(ST, UT) \
   OCTAVE_US_TYPE2_CMP_OP_DECL (<, false, ST, UT) \
@@ -603,7 +603,7 @@
   OCTAVE_US_TYPE2_CMP_OP_DECL (!=, true, ST, UT)
 
 #define OCTAVE_SU_TYPE2_CMP_OP_DECL(OP, LTZ_VAL, ST, UT) \
-  bool operator OP (const octave_int<ST>& lhs, const octave_int<UT>& rhs);
+  bool OCTAVE_API operator OP (const octave_int<ST>& lhs, const octave_int<UT>& rhs);
 
 #define OCTAVE_SU_TYPE2_CMP_OP_DECLS(ST, UT) \
   OCTAVE_SU_TYPE2_CMP_OP_DECL (<, true, ST, UT) \
diff --git a/liboctave/oct-passwd.h b/liboctave/oct-passwd.h
--- a/liboctave/oct-passwd.h
+++ b/liboctave/oct-passwd.h
@@ -31,6 +31,7 @@
 #endif
 
 class
+OCTAVE_API
 octave_passwd
 {
 public:
diff --git a/liboctave/oct-rand.h b/liboctave/oct-rand.h
--- a/liboctave/oct-rand.h
+++ b/liboctave/oct-rand.h
@@ -31,6 +31,7 @@
 #include "dNDArray.h"
 
 struct
+OCTAVE_API
 octave_rand
 {
   // Return the current seed.
diff --git a/liboctave/oct-shlib.h b/liboctave/oct-shlib.h
--- a/liboctave/oct-shlib.h
+++ b/liboctave/oct-shlib.h
@@ -32,6 +32,7 @@
 // octave_shlib objects.
 
 class
+OCTAVE_API
 octave_xshlib
 {
 public:
@@ -40,6 +41,7 @@
 };
 
 class
+OCTAVE_API
 octave_shlib
 {
 public:
diff --git a/liboctave/oct-spparms.h b/liboctave/oct-spparms.h
--- a/liboctave/oct-spparms.h
+++ b/liboctave/oct-spparms.h
@@ -35,6 +35,7 @@
 #define OCTAVE_SPARSE_CONTROLS_SIZE 12
 
 class
+OCTAVE_API
 octave_sparse_params
 {
 protected:
diff --git a/liboctave/oct-syscalls.h b/liboctave/oct-syscalls.h
--- a/liboctave/oct-syscalls.h
+++ b/liboctave/oct-syscalls.h
@@ -33,6 +33,7 @@
 #endif
 
 struct
+OCTAVE_API
 octave_syscalls
 {
   static int dup2 (int, int);
diff --git a/liboctave/oct-time.h b/liboctave/oct-time.h
--- a/liboctave/oct-time.h
+++ b/liboctave/oct-time.h
@@ -33,6 +33,7 @@
 class octave_base_tm;
 
 class
+OCTAVE_API
 octave_time
 {
 public:
@@ -140,6 +141,7 @@
 }
 
 class
+OCTAVE_API
 octave_base_tm
 {
 public:
@@ -247,6 +249,7 @@
 };
 
 class
+OCTAVE_API
 octave_localtime : public octave_base_tm
 {
 public:
@@ -274,6 +277,7 @@
 };
 
 class
+OCTAVE_API
 octave_gmtime : public octave_base_tm
 {
 public:
@@ -298,6 +302,7 @@
 };
 
 class
+OCTAVE_API
 octave_strptime : public octave_base_tm
 {
 public:
diff --git a/liboctave/oct-uname.h b/liboctave/oct-uname.h
--- a/liboctave/oct-uname.h
+++ b/liboctave/oct-uname.h
@@ -27,6 +27,7 @@
 #include <string>
 
 class
+OCTAVE_API
 octave_uname
 {
 public:
diff --git a/liboctave/pathsearch.h b/liboctave/pathsearch.h
--- a/liboctave/pathsearch.h
+++ b/liboctave/pathsearch.h
@@ -29,6 +29,7 @@
 #include "str-vec.h"
 
 class
+OCTAVE_API
 dir_path
 {
 public:
diff --git a/liboctave/prog-args.h b/liboctave/prog-args.h
--- a/liboctave/prog-args.h
+++ b/liboctave/prog-args.h
@@ -34,6 +34,7 @@
 };
 
 class
+OCTAVE_API
 prog_args
 {
 public:
diff --git a/liboctave/so-array.h b/liboctave/so-array.h
--- a/liboctave/so-array.h
+++ b/liboctave/so-array.h
@@ -33,7 +33,7 @@
 
 // Stream offsets.
 
-class streamoff_array : public ArrayN<std::streamoff>
+class OCTAVE_API streamoff_array : public ArrayN<std::streamoff>
 {
 public:
 
@@ -88,11 +88,11 @@
   static std::streamoff resize_fill_value (void) { return 0; }
 };
 
-streamoff_array& operator += (streamoff_array& l, const std::streamoff& r);
-streamoff_array& operator -= (streamoff_array& l, const std::streamoff& r);
+OCTAVE_API streamoff_array& operator += (streamoff_array& l, const std::streamoff& r);
+OCTAVE_API streamoff_array& operator -= (streamoff_array& l, const std::streamoff& r);
 
-streamoff_array& operator += (streamoff_array& l, const streamoff_array& r);
-streamoff_array& operator -= (streamoff_array& l, const streamoff_array& r);
+OCTAVE_API streamoff_array& operator += (streamoff_array& l, const streamoff_array& r);
+OCTAVE_API streamoff_array& operator -= (streamoff_array& l, const streamoff_array& r);
 
 NDCMP_OP_DECL (mx_el_eq, std::streamoff, streamoff_array);
 NDCMP_OP_DECL (mx_el_ne, std::streamoff, streamoff_array);
diff --git a/liboctave/str-vec.h b/liboctave/str-vec.h
--- a/liboctave/str-vec.h
+++ b/liboctave/str-vec.h
@@ -31,6 +31,7 @@
 #include "Array.h"
 
 class
+OCTAVE_API
 string_vector : public Array<std::string>
 {
 public:
diff --git a/liboctave/uint16NDArray.cc b/liboctave/uint16NDArray.cc
--- a/liboctave/uint16NDArray.cc
+++ b/liboctave/uint16NDArray.cc
@@ -30,13 +30,13 @@
 
 #include "intNDArray.cc"
 
-template class intNDArray<octave_uint16>;
+template class OCTAVE_API intNDArray<octave_uint16>;
 
-template
+template OCTAVE_API
 std::ostream&
 operator << (std::ostream& os, const intNDArray<octave_uint16>& a);
 
-template
+template OCTAVE_API
 std::istream&
 operator >> (std::istream& is, intNDArray<octave_uint16>& a);
 
diff --git a/liboctave/uint32NDArray.cc b/liboctave/uint32NDArray.cc
--- a/liboctave/uint32NDArray.cc
+++ b/liboctave/uint32NDArray.cc
@@ -30,13 +30,13 @@
 
 #include "intNDArray.cc"
 
-template class intNDArray<octave_uint32>;
+template class OCTAVE_API intNDArray<octave_uint32>;
 
-template
+template OCTAVE_API
 std::ostream&
 operator << (std::ostream& os, const intNDArray<octave_uint32>& a);
 
-template
+template OCTAVE_API
 std::istream&
 operator >> (std::istream& is, intNDArray<octave_uint32>& a);
 
diff --git a/liboctave/uint64NDArray.cc b/liboctave/uint64NDArray.cc
--- a/liboctave/uint64NDArray.cc
+++ b/liboctave/uint64NDArray.cc
@@ -30,13 +30,13 @@
 
 #include "intNDArray.cc"
 
-template class intNDArray<octave_uint64>;
+template class OCTAVE_API intNDArray<octave_uint64>;
 
-template
+template OCTAVE_API
 std::ostream&
 operator << (std::ostream& os, const intNDArray<octave_uint64>& a);
 
-template
+template OCTAVE_API
 std::istream&
 operator >> (std::istream& is, intNDArray<octave_uint64>& a);
 
diff --git a/liboctave/uint8NDArray.cc b/liboctave/uint8NDArray.cc
--- a/liboctave/uint8NDArray.cc
+++ b/liboctave/uint8NDArray.cc
@@ -30,13 +30,13 @@
 
 #include "intNDArray.cc"
 
-template class intNDArray<octave_uint8>;
+template class OCTAVE_API intNDArray<octave_uint8>;
 
-template
+template OCTAVE_API
 std::ostream&
 operator << (std::ostream& os, const intNDArray<octave_uint8>& a);
 
-template
+template OCTAVE_API
 std::istream&
 operator >> (std::istream& is, intNDArray<octave_uint8>& a);
 
diff --git a/src/ChangeLog b/src/ChangeLog
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,7 +1,13 @@
+2006-10-26  John W. Eaton  <jwe@octave.org>
+
+	* bitfcns.cc (bitshift): If A < 0, return -bitshift (-A, N, MASK).
+
 2006-10-26  Michael Goffioul  <michael.goffioul@swing.be>
 
 	* help.cc (display_help_text): Quote sed patterns with ".
 
+	* file-io.cc: Include file-io.h.
+
 2006-10-26  John W. Eaton  <jwe@octave.org>
 
 	* ov-bool.h (octave_bool::sparse_matrix_value,
diff --git a/src/bitfcns.cc b/src/bitfcns.cc
--- a/src/bitfcns.cc
+++ b/src/bitfcns.cc
@@ -291,6 +291,10 @@
 static int64_t
 bitshift (double a, int n, int64_t mask)
 {
+  // In the name of bug-for-bug compatibility.
+  if (a < 0)
+    return -bitshift (-a, n, mask);
+
   if (n > 0)
     return (static_cast<int64_t> (a) << n) & mask;
   else if (n < 0)
diff --git a/src/file-io.cc b/src/file-io.cc
--- a/src/file-io.cc
+++ b/src/file-io.cc
@@ -62,6 +62,7 @@
 #include "lo-ieee.h"
 
 #include "defun.h"
+#include "file-io.h"
 #include "oct-fstrm.h"
 #include "oct-iostrm.h"
 #include "oct-map.h"