diff options
Diffstat (limited to 'support/aspell/w32/aspell-0.50.4.1-vc++.diff')
-rw-r--r-- | support/aspell/w32/aspell-0.50.4.1-vc++.diff | 4645 |
1 files changed, 4645 insertions, 0 deletions
diff --git a/support/aspell/w32/aspell-0.50.4.1-vc++.diff b/support/aspell/w32/aspell-0.50.4.1-vc++.diff new file mode 100644 index 0000000000..290ce9faf4 --- /dev/null +++ b/support/aspell/w32/aspell-0.50.4.1-vc++.diff @@ -0,0 +1,4645 @@ +Only in aspell-win32: Debug +Only in aspell-win32: Release +Only in aspell-win32: StdAfx.cpp +Only in aspell-win32: StdAfx.h +Only in aspell-win32: aspell.cpp +Only in aspell-win32: aspell.dsp +Only in aspell-win32: aspellroot.h +diff -rubw aspell-0.50.4.1/common/asc_ctype.hpp aspell-win32/common/asc_ctype.hpp +--- aspell-0.50.4.1/common/asc_ctype.hpp 2002-07-23 22:08:14.000000000 -0400 ++++ aspell-win32/common/asc_ctype.hpp 2003-12-30 09:30:08.000000000 -0500 +@@ -14,7 +14,7 @@ + + static inline bool asc_isspace(char c) + { +- return c==' '|c=='\n'|c=='\r'|c=='\t'|c=='\f'|c=='\v'; ++ return (c==' ')|(c=='\n')|(c=='\r')|(c=='\t')|(c=='\f')|(c=='\v'); + } + + static inline bool asc_isdigit(char c) +diff -rubw aspell-0.50.4.1/common/can_have_error.cpp aspell-win32/common/can_have_error.cpp +--- aspell-0.50.4.1/common/can_have_error.cpp 2002-08-26 18:01:04.000000000 -0400 ++++ aspell-win32/common/can_have_error.cpp 2004-01-06 15:28:29.000000000 -0500 +@@ -10,8 +10,11 @@ + + namespace acommon { + ++#ifdef WIN32PORT ++#else + template void GenericCopyPtr<Error, CopyPtr<Error>::Parms> + ::reset(Error*, CopyPtr<Error>::Parms const&); ++#endif + + CanHaveError::CanHaveError(Error * e) + : err_(e) +diff -rubw aspell-0.50.4.1/common/can_have_error.hpp aspell-win32/common/can_have_error.hpp +--- aspell-0.50.4.1/common/can_have_error.hpp 2002-08-26 18:42:06.000000000 -0400 ++++ aspell-win32/common/can_have_error.hpp 2004-01-06 15:28:31.000000000 -0500 +@@ -9,6 +9,9 @@ + + #include "copy_ptr.hpp" + #include "error.hpp" ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + namespace acommon { + +diff -rubw aspell-0.50.4.1/common/char_vector.hpp aspell-win32/common/char_vector.hpp +--- aspell-0.50.4.1/common/char_vector.hpp 2002-08-04 02:20:32.000000000 -0400 ++++ aspell-win32/common/char_vector.hpp 2004-01-06 15:28:32.000000000 -0500 +@@ -9,6 +9,9 @@ + + #include "vector.hpp" + #include "ostream.hpp" ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + namespace acommon + { +diff -rubw aspell-0.50.4.1/common/clone_ptr-t.hpp aspell-win32/common/clone_ptr-t.hpp +--- aspell-0.50.4.1/common/clone_ptr-t.hpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/clone_ptr-t.hpp 2004-01-06 15:28:35.000000000 -0500 +@@ -15,10 +15,16 @@ + + #include "clone_ptr.hpp" + #include <typeinfo> ++#ifdef WIN32PORT ++#include "generic_copy_ptr.hpp" ++#else + #include "generic_copy_ptr-t.hpp" ++#endif + + namespace acommon { + ++#ifdef WIN32PORT ++#else + template <typename T> + inline T * ClonePtr<T>::Parms::clone(const T * ptr) const { + return ptr->clone(); +@@ -39,6 +45,7 @@ + inline void ClonePtr<T>::Parms::del(T * ptr) { + delete ptr; + } ++#endif + + } + +diff -rubw aspell-0.50.4.1/common/clone_ptr.hpp aspell-win32/common/clone_ptr.hpp +--- aspell-0.50.4.1/common/clone_ptr.hpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/clone_ptr.hpp 2004-01-06 15:28:38.000000000 -0500 +@@ -21,9 +21,30 @@ + class ClonePtr + { + struct Parms { ++#ifdef WIN32PORT ++ T * clone(const T * ptr) const{return ptr->clone();} ++#else + T * clone(const T * ptr) const; ++#endif ++#ifdef WIN32PORT ++ void assign(T * & rhs, const T * lhs) const{ ++ if (typeid(*rhs) == typeid(*lhs)) { ++ rhs->assign(lhs); ++ } else { ++ T * temp = rhs; ++ rhs = lhs->clone(); ++ delete temp; ++ } ++ } ++#else + void assign(T * & rhs, const T * lhs) const; ++#endif ++#ifdef WIN32PORT ++ void del(T * ptr){delete ptr;} ++#else + void del(T * ptr); ++#endif ++ + }; + GenericCopyPtr<T, Parms> impl; + +diff -rubw aspell-0.50.4.1/common/config.cpp aspell-win32/common/config.cpp +--- aspell-0.50.4.1/common/config.cpp 2002-08-25 22:04:34.000000000 -0400 ++++ aspell-win32/common/config.cpp 2004-01-06 15:28:41.000000000 -0500 +@@ -9,7 +9,10 @@ + #include <assert.h> + #include <locale.h> + ++#ifdef WIN32PORT ++#else + #include "dirs.h" ++#endif + #include "settings.h" + + #include "asc_ctype.hpp" +@@ -283,10 +286,18 @@ + const KeyInfo * i; + + i = acommon::find(key, kmi.main_begin, kmi.main_end); ++#ifdef WIN32PORT ++ if (i != kmi.main_end) return ret = PosibErr<const KeyInfo*>(i); //FB ++#else + if (i != kmi.main_end) return ret = i; ++#endif + ++#ifdef WIN32PORT + i = acommon::find(key, kmi.extra_begin, kmi.extra_end); ++ if (i != kmi.extra_end) return ret = PosibErr<const KeyInfo*>(i); //FB ++#else + if (i != kmi.extra_end) return ret = i; ++#endif + + const char * h = strchr(key, '-'); + +@@ -301,7 +312,11 @@ + return ret.prim_err(unknown_key, key); + + i = acommon::find(key, j->begin, j->end); ++#ifdef WIN32PORT ++ if (i != j->end) return ret = PosibErr<const KeyInfo*>(i); //FB ++#else + if (i != j->end) return ret = i; ++#endif + + return ret.prim_err(unknown_key, key); + } +diff -rubw aspell-0.50.4.1/common/config.hpp aspell-win32/common/config.hpp +--- aspell-0.50.4.1/common/config.hpp 2002-08-12 20:10:18.000000000 -0400 ++++ aspell-win32/common/config.hpp 2004-01-02 13:01:11.000000000 -0500 +@@ -93,68 +93,68 @@ + + String temp_str; + +- Config(ParmString name, ++ ASPELL_API Config(ParmString name, + const KeyInfo * mainbegin, + const KeyInfo * mainend); + +- Config(const Config &); +- ~Config(); +- Config & operator= (const Config &); ++ ASPELL_API Config(const Config &); ++ ASPELL_API ~Config(); ++ ASPELL_API Config & operator= (const Config &); + +- bool get_attached() const {return attached_;} +- void set_attached(bool a) {attached_ = a;} ++ ASPELL_API bool get_attached() const {return attached_;} ++ ASPELL_API void set_attached(bool a) {attached_ = a;} + +- Config * clone() const; +- void assign(const Config * other); ++ ASPELL_API Config * clone() const; ++ ASPELL_API void assign(const Config * other); + +- const char * name() const {return name_.c_str();} ++ ASPELL_API const char * name() const {return name_.c_str();} + +- NotifierEnumeration * notifiers() const; ++ ASPELL_API NotifierEnumeration * notifiers() const; + +- bool add_notifier ( Notifier *); +- bool remove_notifier (const Notifier *); +- bool replace_notifier(const Notifier *, Notifier *); ++ ASPELL_API bool add_notifier ( Notifier *); ++ ASPELL_API bool remove_notifier (const Notifier *); ++ ASPELL_API bool replace_notifier(const Notifier *, Notifier *); + +- void set_extra(const KeyInfo * begin, const KeyInfo * end); ++ ASPELL_API void set_extra(const KeyInfo * begin, const KeyInfo * end); + +- void set_modules(const ConfigModule * modbegin, const ConfigModule * modend); ++ ASPELL_API void set_modules(const ConfigModule * modbegin, const ConfigModule * modend); + +- static const char * base_name(ParmString name); ++ ASPELL_API static const char * base_name(ParmString name); + +- PosibErr<const KeyInfo *> keyinfo(ParmString key) const; ++ ASPELL_API PosibErr<const KeyInfo *> keyinfo(ParmString key) const; + +- KeyInfoEnumeration * possible_elements(bool include_extra = true); ++ ASPELL_API KeyInfoEnumeration * possible_elements(bool include_extra = true); + +- StringPairEnumeration * elements(); ++ ASPELL_API StringPairEnumeration * elements(); + +- PosibErr<String> get_default (ParmString key) const; ++ ASPELL_API PosibErr<String> get_default (ParmString key) const; + +- PosibErr<String> retrieve (ParmString key) const; ++ ASPELL_API PosibErr<String> retrieve (ParmString key) const; + +- bool have (ParmString key) const; ++ ASPELL_API bool have (ParmString key) const; + +- PosibErr<void> retrieve_list (ParmString key, MutableContainer *) const; +- PosibErr<bool> retrieve_bool (ParmString key) const; +- PosibErr<int> retrieve_int (ParmString key) const; ++ ASPELL_API PosibErr<void> retrieve_list (ParmString key, MutableContainer *) const; ++ ASPELL_API PosibErr<bool> retrieve_bool (ParmString key) const; ++ ASPELL_API PosibErr<int> retrieve_int (ParmString key) const; + +- PosibErr<void> replace (ParmString, ParmString); +- PosibErr<bool> remove (ParmString); ++ ASPELL_API PosibErr<void> replace (ParmString, ParmString); ++ ASPELL_API PosibErr<bool> remove (ParmString); + +- void write_to_stream(OStream & out, bool include_extra = false); ++ ASPELL_API void write_to_stream(OStream & out, bool include_extra = false); + +- PosibErr<void> read_in_settings(const Config * override = 0); ++ ASPELL_API PosibErr<void> read_in_settings(const Config * override = 0); + +- PosibErr<void> read_in(IStream & in); +- PosibErr<void> read_in_file(ParmString file); +- PosibErr<void> read_in_string(ParmString str); ++ ASPELL_API PosibErr<void> read_in(IStream & in); ++ ASPELL_API PosibErr<void> read_in_file(ParmString file); ++ ASPELL_API PosibErr<void> read_in_string(ParmString str); + +- void merge(const Config &); ++ ASPELL_API void merge(const Config &); + //Note: if the same key is in both config's it is assumed that they + // have the same data type. + }; + +- Config * new_config(); +- Config * new_basic_config(); // config which doesn't require any ++ ASPELL_API Config * new_config(); ++ ASPELL_API Config * new_basic_config(); // config which doesn't require any + // external symbols + + class NotifierEnumeration { +diff -rubw aspell-0.50.4.1/common/convert.cpp aspell-win32/common/convert.cpp +--- aspell-0.50.4.1/common/convert.cpp 2002-08-24 20:38:38.000000000 -0400 ++++ aspell-win32/common/convert.cpp 2004-01-08 12:21:08.000000000 -0500 +@@ -6,6 +6,9 @@ + + #include <string.h> + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "asc_ctype.hpp" + #include "convert.hpp" + #include "fstream.hpp" +@@ -37,7 +40,11 @@ + class ToUniLookup + { + Uni32 data[256]; ++#ifdef WIN32PORT ++ static const Uni32 npos; // FB = (Uni32)(-1); ++#else + static const Uni32 npos = (Uni32)(-1); ++#endif + public: + void reset(); + Uni32 operator[] (char key) const {return data[(unsigned char)key];} +@@ -45,6 +52,10 @@ + bool insert(char key, Uni32 value); + }; + ++#ifdef WIN32PORT ++ const Uni32 ToUniLookup::npos = (Uni32)(-1); // FB ++#endif ++ + void ToUniLookup::reset() + { + for (int i = 0; i != 256; ++i) +@@ -82,7 +93,11 @@ + { + private: + char unknown; ++#ifdef WIN32PORT ++ static const Uni32 npos; // FB = (Uni32)(-1); ++#else + static const Uni32 npos = (Uni32)(-1); ++#endif + UniItem * overflow_end; + + UniItem data[256*4]; +@@ -96,6 +111,10 @@ + bool insert(Uni32 key, char value); + }; + ++#ifdef WIN32PORT ++ const Uni32 FromUniLookup::npos = (Uni32)(-1); // FB ++#endif ++ + void FromUniLookup::reset() + { + for (unsigned int i = 0; i != 256*4; ++i) +@@ -244,8 +263,12 @@ + for (;*in; ++in) + out.append(*in); + } else { ++#ifdef WIN32PORT ++ for (;size--; ++in) ++#else + const Chr * stop = reinterpret_cast<const Chr *>(in0 +size); + for (;in != stop; ++in) ++#endif + out.append(*in); + } + } +diff -rubw aspell-0.50.4.1/common/convert.hpp aspell-win32/common/convert.hpp +--- aspell-0.50.4.1/common/convert.hpp 2002-08-10 12:17:06.000000000 -0400 ++++ aspell-win32/common/convert.hpp 2004-01-06 15:28:48.000000000 -0500 +@@ -57,7 +57,10 @@ + + FilterCharVector buf; + ++#ifdef WIN32PORT ++#else + static const unsigned int null_len_ = 4; // POSIB FIXME: Be more precise ++#endif + + public: + +@@ -73,11 +76,20 @@ + + void append_null(CharVector & out) const + { ++#ifdef WIN32PORT ++ const char nul[8] = {0, 0, 0, 0, 0 ,0 ,0, 0}; // FB // 8 should be more than enough ++ out.write(nul, /*null_len_*/4); //FB ++#else + const char nul[8] = {0}; // 8 should be more than enough + out.write(nul, null_len_); ++#endif + } + ++#ifdef WIN32PORT ++ unsigned int null_len() const {return /*null_len_*/4;} ++#else + unsigned int null_len() const {return null_len_;} ++#endif + + // this filters will generally not translate null characters + // if you need a null character at the end, add it yourself +diff -rubw aspell-0.50.4.1/common/copy_ptr-t.hpp aspell-win32/common/copy_ptr-t.hpp +--- aspell-0.50.4.1/common/copy_ptr-t.hpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/copy_ptr-t.hpp 2004-01-06 15:28:50.000000000 -0500 +@@ -14,10 +14,16 @@ + #define autil__copy_ptr_t + + #include "copy_ptr.hpp" ++#ifdef WIN32PORT ++#include "generic_copy_ptr.hpp" ++#else + #include "generic_copy_ptr-t.hpp" ++#endif + + namespace acommon { + ++#ifdef WIN32PORT ++#else + template <typename T> + T * CopyPtr<T>::Parms::clone(const T * ptr) const { + return new T(*ptr); +@@ -32,6 +38,7 @@ + void CopyPtr<T>::Parms::del(T * ptr) { + delete ptr; + } ++#endif + } + + #endif +diff -rubw aspell-0.50.4.1/common/copy_ptr.hpp aspell-win32/common/copy_ptr.hpp +--- aspell-0.50.4.1/common/copy_ptr.hpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/copy_ptr.hpp 2004-01-06 15:28:52.000000000 -0500 +@@ -13,17 +13,28 @@ + #ifndef autil__copy_ptr + #define autil__copy_ptr + ++#ifdef WIN32PORT ++#include "generic_copy_ptr-t.hpp" //FB ++#include "aspellroot.h" ++#else + #include "generic_copy_ptr.hpp" ++#endif + + namespace acommon { + + template <typename T> +- class CopyPtr ++ class ASPELL_API CopyPtr + { + struct Parms { ++#ifdef WIN32PORT ++ T * clone(const T * ptr) const {return new T(*ptr);} //FB ++ void assign(T * & rhs, const T * lhs) const{*rhs = *lhs;} //FB ++ void del(T * ptr){ delete ptr; } //FB ++#else + T * clone(const T * ptr) const; + void assign(T * & rhs, const T * lhs) const; + void del(T * ptr); ++#endif + }; + GenericCopyPtr<T, Parms> impl; + +diff -rubw aspell-0.50.4.1/common/document_checker.hpp aspell-win32/common/document_checker.hpp +--- aspell-0.50.4.1/common/document_checker.hpp 2002-08-10 12:17:06.000000000 -0400 ++++ aspell-win32/common/document_checker.hpp 2004-01-06 15:28:55.000000000 -0500 +@@ -13,6 +13,9 @@ + #include "can_have_error.hpp" + #include "filter_char.hpp" + #include "filter_char_vector.hpp" ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + namespace acommon { + +@@ -35,12 +38,12 @@ + // speller expected to stick around. + PosibErr<void> setup(Tokenizer *, Speller *, Filter *); + void reset(); +- void process(const char * str, int size); +- Token next_misspelling(); ++ ASPELL_API void process(const char * str, int size); ++ ASPELL_API Token next_misspelling(); + + Filter * filter() {return filter_;} + +- void set_status_fun(void (*)(void *, Token, int), void *); ++ ASPELL_API void set_status_fun(void (*)(void *, Token, int), void *); + + DocumentChecker(); + ~DocumentChecker(); +@@ -55,7 +58,7 @@ + FilterCharVector proc_str_; + }; + +- PosibErr<DocumentChecker *> new_document_checker(Speller *); ++ ASPELL_API PosibErr<DocumentChecker *> new_document_checker(Speller *); + + } + +diff -rubw aspell-0.50.4.1/common/enumeration.hpp aspell-win32/common/enumeration.hpp +--- aspell-0.50.4.1/common/enumeration.hpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/enumeration.hpp 2004-01-06 15:28:57.000000000 -0500 +@@ -115,21 +115,29 @@ + } + }; + ++ + template <class Value> + struct MakeAlwaysEndEnumerationParms { + Value end_state() const {return Value();} + }; + ++#ifdef WIN32PORT ++#else + template <class Value> + struct MakeAlwaysEndEnumerationParms<Value *> { + Value * end_state() const {return 0;} + }; ++#endif + + template <class Value> + class MakeAlwaysEndEnumeration : public VirEnumeration<Value> { + MakeAlwaysEndEnumerationParms<Value> parms_; + public: ++#ifdef WIN32PORT ++ /*MakeAlwaysEndEnumeration*/VirEnumeration<Value> * clone() const {//FB ++#else + MakeAlwaysEndEnumeration * clone() const { ++#endif + return new MakeAlwaysEndEnumeration(*this); + } + void assign(const VirEnumeration<Value> * that) { +diff -rubw aspell-0.50.4.1/common/error.hpp aspell-win32/common/error.hpp +--- aspell-0.50.4.1/common/error.hpp 2002-07-27 06:49:40.000000000 -0400 ++++ aspell-win32/common/error.hpp 2004-01-06 15:28:59.000000000 -0500 +@@ -7,12 +7,15 @@ + #ifndef ASPELL_ERROR__HPP + #define ASPELL_ERROR__HPP + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + namespace acommon { + + struct ErrorInfo; + +-struct Error { ++struct ASPELL_API Error { + const char * mesg; // expected to be allocated with new[] + const ErrorInfo * err; + +@@ -25,7 +28,7 @@ + bool is_a(const ErrorInfo * e) const; + }; + +-struct ErrorInfo { ++struct ASPELL_API ErrorInfo { + const ErrorInfo * isa; + const char * mesg; + unsigned int num_parms; +diff -rubw aspell-0.50.4.1/common/errors.cpp aspell-win32/common/errors.cpp +--- aspell-0.50.4.1/common/errors.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/common/errors.cpp 2004-01-06 15:29:05.000000000 -0500 +@@ -16,7 +16,11 @@ + 0, // isa + 0, // mesg + 0, // num_parms ++#ifdef WIN32PORT ++ {""} // FB // parms ++#else + {} // parms ++#endif + }; + extern "C" const ErrorInfo * const aerror_other = &aerror_other_obj; + +@@ -24,7 +28,11 @@ + 0, // isa + 0, // mesg + 0, // num_parms ++#ifdef WIN32PORT ++ {""} // FB // parms ++#else + {} // parms ++#endif + }; + extern "C" const ErrorInfo * const aerror_operation_not_supported = &aerror_operation_not_supported_obj; + +@@ -32,7 +40,11 @@ + aerror_operation_not_supported, // isa + 0, // mesg + 0, // num_parms ++#ifdef WIN32PORT ++ {""} // FB // parms ++#else + {} // parms ++#endif + }; + extern "C" const ErrorInfo * const aerror_cant_copy = &aerror_cant_copy_obj; + +@@ -232,7 +244,11 @@ + 0, // isa + 0, // mesg + 0, // num_parms ++#ifdef WIN32PORT ++ {""} // FB // parms ++#else + {} // parms ++#endif + }; + extern "C" const ErrorInfo * const aerror_pipe = &aerror_pipe_obj; + +@@ -240,7 +256,11 @@ + aerror_pipe, // isa + 0, // mesg + 0, // num_parms ++#ifdef WIN32PORT ++ {""} // FB // parms ++#else + {} // parms ++#endif + }; + extern "C" const ErrorInfo * const aerror_cant_create_pipe = &aerror_cant_create_pipe_obj; + +@@ -248,7 +268,11 @@ + aerror_pipe, // isa + 0, // mesg + 0, // num_parms ++#ifdef WIN32PORT ++ {""} // FB // parms ++#else + {} // parms ++#endif + }; + extern "C" const ErrorInfo * const aerror_process_died = &aerror_process_died_obj; + +@@ -256,7 +280,11 @@ + 0, // isa + 0, // mesg + 0, // num_parms ++#ifdef WIN32PORT ++ {""} // FB // parms ++#else + {} // parms ++#endif + }; + extern "C" const ErrorInfo * const aerror_bad_input = &aerror_bad_input_obj; + +@@ -272,7 +300,11 @@ + aerror_bad_input, // isa + 0, // mesg + 0, // num_parms ++#ifdef WIN32PORT ++ {""} // FB // parms ++#else + {} // parms ++#endif + }; + extern "C" const ErrorInfo * const aerror_word_list_flags = &aerror_word_list_flags_obj; + +@@ -280,7 +312,11 @@ + aerror_word_list_flags, // isa + 0, // mesg + 0, // num_parms ++#ifdef WIN32PORT ++ {""} // FB // parms ++#else + {} // parms ++#endif + }; + extern "C" const ErrorInfo * const aerror_invalid_flag = &aerror_invalid_flag_obj; + +@@ -288,7 +324,11 @@ + aerror_word_list_flags, // isa + 0, // mesg + 0, // num_parms ++#ifdef WIN32PORT ++ {""} // FB // parms ++#else + {} // parms ++#endif + }; + extern "C" const ErrorInfo * const aerror_conflicting_flags = &aerror_conflicting_flags_obj; + +diff -rubw aspell-0.50.4.1/common/errors.hpp aspell-win32/common/errors.hpp +--- aspell-0.50.4.1/common/errors.hpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/common/errors.hpp 2004-01-06 15:29:07.000000000 -0500 +@@ -9,46 +9,49 @@ + #ifndef ASPELL_ERRORS__HPP + #define ASPELL_ERRORS__HPP + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + namespace acommon { + + struct ErrorInfo; + +-extern "C" const ErrorInfo * const aerror_other; +-extern "C" const ErrorInfo * const aerror_operation_not_supported; +-extern "C" const ErrorInfo * const aerror_cant_copy; +-extern "C" const ErrorInfo * const aerror_file; +-extern "C" const ErrorInfo * const aerror_cant_open_file; +-extern "C" const ErrorInfo * const aerror_cant_read_file; +-extern "C" const ErrorInfo * const aerror_cant_write_file; +-extern "C" const ErrorInfo * const aerror_invalid_name; +-extern "C" const ErrorInfo * const aerror_bad_file_format; +-extern "C" const ErrorInfo * const aerror_dir; +-extern "C" const ErrorInfo * const aerror_cant_read_dir; +-extern "C" const ErrorInfo * const aerror_config; +-extern "C" const ErrorInfo * const aerror_unknown_key; +-extern "C" const ErrorInfo * const aerror_cant_change_value; +-extern "C" const ErrorInfo * const aerror_bad_key; +-extern "C" const ErrorInfo * const aerror_bad_value; +-extern "C" const ErrorInfo * const aerror_duplicate; +-extern "C" const ErrorInfo * const aerror_language_related; +-extern "C" const ErrorInfo * const aerror_unknown_language; +-extern "C" const ErrorInfo * const aerror_unknown_soundslike; +-extern "C" const ErrorInfo * const aerror_language_not_supported; +-extern "C" const ErrorInfo * const aerror_no_wordlist_for_lang; +-extern "C" const ErrorInfo * const aerror_mismatched_language; +-extern "C" const ErrorInfo * const aerror_encoding; +-extern "C" const ErrorInfo * const aerror_unknown_encoding; +-extern "C" const ErrorInfo * const aerror_encoding_not_supported; +-extern "C" const ErrorInfo * const aerror_conversion_not_supported; +-extern "C" const ErrorInfo * const aerror_pipe; +-extern "C" const ErrorInfo * const aerror_cant_create_pipe; +-extern "C" const ErrorInfo * const aerror_process_died; +-extern "C" const ErrorInfo * const aerror_bad_input; +-extern "C" const ErrorInfo * const aerror_invalid_word; +-extern "C" const ErrorInfo * const aerror_word_list_flags; +-extern "C" const ErrorInfo * const aerror_invalid_flag; +-extern "C" const ErrorInfo * const aerror_conflicting_flags; ++extern "C" ASPELL_API const ErrorInfo * const aerror_other; ++extern "C" ASPELL_API const ErrorInfo * const aerror_operation_not_supported; ++extern "C" ASPELL_API const ErrorInfo * const aerror_cant_copy; ++extern "C" ASPELL_API const ErrorInfo * const aerror_file; ++extern "C" ASPELL_API const ErrorInfo * const aerror_cant_open_file; ++extern "C" ASPELL_API const ErrorInfo * const aerror_cant_read_file; ++extern "C" ASPELL_API const ErrorInfo * const aerror_cant_write_file; ++extern "C" ASPELL_API const ErrorInfo * const aerror_invalid_name; ++extern "C" ASPELL_API const ErrorInfo * const aerror_bad_file_format; ++extern "C" ASPELL_API const ErrorInfo * const aerror_dir; ++extern "C" ASPELL_API const ErrorInfo * const aerror_cant_read_dir; ++extern "C" ASPELL_API const ErrorInfo * const aerror_config; ++extern "C" ASPELL_API const ErrorInfo * const aerror_unknown_key; ++extern "C" ASPELL_API const ErrorInfo * const aerror_cant_change_value; ++extern "C" ASPELL_API const ErrorInfo * const aerror_bad_key; ++extern "C" ASPELL_API const ErrorInfo * const aerror_bad_value; ++extern "C" ASPELL_API const ErrorInfo * const aerror_duplicate; ++extern "C" ASPELL_API const ErrorInfo * const aerror_language_related; ++extern "C" ASPELL_API const ErrorInfo * const aerror_unknown_language; ++extern "C" ASPELL_API const ErrorInfo * const aerror_unknown_soundslike; ++extern "C" ASPELL_API const ErrorInfo * const aerror_language_not_supported; ++extern "C" ASPELL_API const ErrorInfo * const aerror_no_wordlist_for_lang; ++extern "C" ASPELL_API const ErrorInfo * const aerror_mismatched_language; ++extern "C" ASPELL_API const ErrorInfo * const aerror_encoding; ++extern "C" ASPELL_API const ErrorInfo * const aerror_unknown_encoding; ++extern "C" ASPELL_API const ErrorInfo * const aerror_encoding_not_supported; ++extern "C" ASPELL_API const ErrorInfo * const aerror_conversion_not_supported; ++extern "C" ASPELL_API const ErrorInfo * const aerror_pipe; ++extern "C" ASPELL_API const ErrorInfo * const aerror_cant_create_pipe; ++extern "C" ASPELL_API const ErrorInfo * const aerror_process_died; ++extern "C" ASPELL_API const ErrorInfo * const aerror_bad_input; ++extern "C" ASPELL_API const ErrorInfo * const aerror_invalid_word; ++extern "C" ASPELL_API const ErrorInfo * const aerror_word_list_flags; ++extern "C" ASPELL_API const ErrorInfo * const aerror_invalid_flag; ++extern "C" ASPELL_API const ErrorInfo * const aerror_conflicting_flags; + + + static const ErrorInfo * const other_error = aerror_other; +diff -rubw aspell-0.50.4.1/common/file_util.cpp aspell-win32/common/file_util.cpp +--- aspell-0.50.4.1/common/file_util.cpp 2002-11-04 18:39:40.000000000 -0500 ++++ aspell-win32/common/file_util.cpp 2004-01-06 15:29:12.000000000 -0500 +@@ -19,7 +19,12 @@ + + // This needs to be <stdio.h> and not <cstdio> + #include <stdio.h> ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#include <io.h> //FB (for _access) ++#else + #include <unistd.h> ++#endif + #include <sys/stat.h> + + +@@ -78,8 +83,15 @@ + fl.l_whence = SEEK_SET; + fl.l_start = 0; + fl.l_len = 0; ++#ifdef WIN32PORT ++ if (fcntl(fd, F_SETLKW, &fl) == -1) { ++ in.close(); ++ return make_err(cant_read_file, file); ++ } ++#else + fcntl(fd, F_SETLKW, &fl); // ignore errors + #endif ++#endif + return no_err; + } + +@@ -102,7 +114,12 @@ + fl.l_whence = SEEK_SET; + fl.l_start = 0; + fl.l_len = 0; ++#ifdef WIN32PORT ++ if (fcntl(fd, F_SETLKW, &fl) == -1) ++ return Ret().prim_err(cant_write_file, file); ++#else + fcntl(fd, F_SETLKW, &fl); // ignore errors ++#endif + struct stat s; + fstat(fd, &s); + return s.st_size != 0; +@@ -126,7 +143,11 @@ + } + + bool file_exists(ParmString name) { ++#ifdef WIN32PORT ++ return _access(name, 0) == 0; ++#else + return access(name, F_OK) == 0; ++#endif + //struct stat fileinfo; + //return stat(name, &fileinfo) == 0; + } +diff -rubw aspell-0.50.4.1/common/file_util.hpp aspell-win32/common/file_util.hpp +--- aspell-0.50.4.1/common/file_util.hpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/file_util.hpp 2004-01-02 12:58:34.000000000 -0500 +@@ -16,21 +16,21 @@ + + class FStream; + +- bool need_dir(ParmString file); +- String add_possible_dir(ParmString dir, ParmString file); +- String figure_out_dir(ParmString dir, ParmString file); ++ bool ASPELL_API need_dir(ParmString file); ++ String ASPELL_API add_possible_dir(ParmString dir, ParmString file); ++ String ASPELL_API figure_out_dir(ParmString dir, ParmString file); + + // FIXME: Possible remove + //void open_file(FStream & in, const string & file, + // ParmString mode = "r"); +- time_t get_modification_time(FStream & f); +- PosibErr<void> open_file_readlock(FStream& in, ParmString file); +- PosibErr<bool> open_file_writelock(FStream & in, ParmString file); ++ time_t ASPELL_API get_modification_time(FStream & f); ++ PosibErr<void> ASPELL_API open_file_readlock(FStream& in, ParmString file); ++ PosibErr<bool> ASPELL_API open_file_writelock(FStream & in, ParmString file); + // returns true if the file already exists +- void truncate_file(FStream & f, ParmString name); +- bool remove_file(ParmString name); +- bool file_exists(ParmString name); +- bool rename_file(ParmString orig, ParmString new_name); ++ void ASPELL_API truncate_file(FStream & f, ParmString name); ++ bool ASPELL_API remove_file(ParmString name); ++ bool ASPELL_API file_exists(ParmString name); ++ bool ASPELL_API rename_file(ParmString orig, ParmString new_name); + // will return NULL if path is NULL. + const char * get_file_name(const char * path); + } +diff -rubw aspell-0.50.4.1/common/filter.hpp aspell-win32/common/filter.hpp +--- aspell-0.50.4.1/common/filter.hpp 2002-08-15 20:12:50.000000000 -0400 ++++ aspell-win32/common/filter.hpp 2004-01-06 15:29:14.000000000 -0500 +@@ -12,6 +12,9 @@ + #include "filter_char.hpp" + #include "posib_err.hpp" + #include "vector.hpp" ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + namespace acommon { + +@@ -36,7 +39,7 @@ + Filters filters_; + }; + +- void set_mode_from_extension(Config * config, ++ void ASPELL_API set_mode_from_extension(Config * config, + ParmString filename); + + PosibErr<void> setup_filter(Filter &, Config *, +diff -rubw aspell-0.50.4.1/common/filter_char.hpp aspell-win32/common/filter_char.hpp +--- aspell-0.50.4.1/common/filter_char.hpp 2002-08-20 20:47:28.000000000 -0400 ++++ aspell-win32/common/filter_char.hpp 2004-01-06 15:29:17.000000000 -0500 +@@ -7,9 +7,13 @@ + // license along with this library if you did not you can find + // it at http://www.gnu.org/. + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif ++ + namespace acommon { + +- struct FilterChar { ++ struct ASPELL_API FilterChar { + unsigned int chr; + unsigned int width; // width must always be < 256 + typedef unsigned int Chr; +diff -rubw aspell-0.50.4.1/common/filter_char_vector.hpp aspell-win32/common/filter_char_vector.hpp +--- aspell-0.50.4.1/common/filter_char_vector.hpp 2002-08-11 09:58:30.000000000 -0400 ++++ aspell-win32/common/filter_char_vector.hpp 2004-01-06 15:29:20.000000000 -0500 +@@ -7,6 +7,9 @@ + // license along with this library if you did not you can find + // it at http://www.gnu.org/. + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "filter_char.hpp" + + namespace acommon { +diff -rubw aspell-0.50.4.1/common/fstream.hpp aspell-win32/common/fstream.hpp +--- aspell-0.50.4.1/common/fstream.hpp 2002-09-18 09:38:18.000000000 -0400 ++++ aspell-win32/common/fstream.hpp 2004-01-06 15:29:24.000000000 -0500 +@@ -12,14 +12,20 @@ + #include "istream.hpp" + #include "ostream.hpp" + #include "posib_err.hpp" ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + // NOTE: See iostream.hpp for the standard stream (ie standard input, + // output, error) ++#ifdef WIN32PORT ++using namespace std; // FB ++#endif + + namespace acommon { + class String; + +- class FStream : public IStream, public OStream ++ class ASPELL_API FStream : public IStream, public OStream + { + private: + FILE * file_; +@@ -43,7 +49,11 @@ + + // NOTE: Use c_stream only as a last resort as it may + // disappear if the underlining impl changes ++#ifdef WIN32PORT ++ FILE * c_stream(); // FB ++#else + std::FILE * c_stream(); ++#endif + // However, file_no will always be available. + int file_no(); + +diff -rubw aspell-0.50.4.1/common/generic_copy_ptr.hpp aspell-win32/common/generic_copy_ptr.hpp +--- aspell-0.50.4.1/common/generic_copy_ptr.hpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/generic_copy_ptr.hpp 2004-01-06 15:29:26.000000000 -0500 +@@ -13,6 +13,10 @@ + #ifndef autil__generic_copy_ptr + #define autil__generic_copy_ptr + ++#ifdef WIN32PORT ++#pragma warning(disable:4786) ++#endif ++ + namespace acommon { + + // Parms is expected to have the following members +diff -rubw aspell-0.50.4.1/common/hash-t.hpp aspell-win32/common/hash-t.hpp +--- aspell-0.50.4.1/common/hash-t.hpp 2002-08-11 09:58:30.000000000 -0400 ++++ aspell-win32/common/hash-t.hpp 2004-01-16 08:50:37.000000000 -0500 +@@ -84,11 +84,19 @@ + } + + template <class P> ++#ifdef WIN32PORT ++ std::pair< HashTable<P>::iterator,bool> HashTable<P>::insert(const Value & to_insert) //FB ++#else + std::pair<typename HashTable<P>::iterator,bool> HashTable<P>::insert(const Value & to_insert) ++#endif + { + bool have; + iterator put_me_here = find_i(parms_.key(to_insert), have); ++#ifdef WIN32PORT ++ if (have && !parms_.is_multi()) //FB ++#else + if (have && !parms_.is_multi) ++#endif + return std::pair<iterator,bool>(put_me_here,false); + Node * new_node = node_pool_.new_node(); + if (new_node == 0) { +@@ -152,7 +160,11 @@ + } + + template <class P> ++#ifdef WIN32PORT ++ std::pair<HashTable<P>::iterator, HashTable<P>::iterator>//FB ++#else + std::pair<typename HashTable<P>::iterator, typename HashTable<P>::iterator> ++#endif + HashTable<P>::equal_range_i(const Key & to_find, int & c) + { + c = 0; +@@ -174,6 +186,10 @@ + template <class P> + void HashTable<P>::del() + { ++#ifdef WIN32PORT ++ typedef typename P::Value value_type; //FB ++ typedef value_type Value; //FB ++#endif + for (Node * * i = table_; i != table_end_; ++i) { + Node * n = *i; + while (n != 0) { +diff -rubw aspell-0.50.4.1/common/hash.hpp aspell-win32/common/hash.hpp +--- aspell-0.50.4.1/common/hash.hpp 2002-08-11 09:58:30.000000000 -0400 ++++ aspell-win32/common/hash.hpp 2004-01-06 15:29:34.000000000 -0500 +@@ -145,7 +145,11 @@ + const_iterator begin() const {return const_iterator(table_);} + const_iterator end() const {return const_iterator(table_end_,*table_end_);} + size_type size() const {return size_;} ++#ifdef WIN32PORT ++ bool empty() const {return size_ + 1 != 0;} ++#else + bool empty() const {return size_ + 1;} ++#endif + std::pair<iterator,bool> insert(const value_type &); + void erase(iterator); + size_type erase(const key_type &); +@@ -258,9 +262,17 @@ + template <typename K, typename HF, typename E, bool m> + struct HashSetParms + { ++#ifdef WIN32PORT ++ typedef K Value; ++#else + typedef const K Value; ++#endif + typedef const K Key; ++#ifdef WIN32PORT ++ bool is_multi(){ return m; } //FB ++#else + static const bool is_multi = m; ++#endif + HF hash; + E equal; + const K & key(const K & v) {return v;} +@@ -294,7 +306,11 @@ + { + typedef std::pair<const K,V> Value; + typedef const K Key; ++#ifdef WIN32PORT ++ bool is_multi(){ return m; } //FB ++#else + static const bool is_multi = m; ++#endif + HF hash; + E equal; + const K & key(const Value & v) {return v.first;} +diff -rubw aspell-0.50.4.1/common/info.cpp aspell-win32/common/info.cpp +--- aspell-0.50.4.1/common/info.cpp 2002-11-25 19:21:50.000000000 -0500 ++++ aspell-win32/common/info.cpp 2004-01-06 15:29:41.000000000 -0500 +@@ -14,7 +14,12 @@ + /* BSDi defines u_intXX_t types in machine/types.h */ + #include <machine/types.h> + #endif ++#ifdef WIN32PORT ++#include <windows.h> //FB ++#include <winbase.h> //FB ++#else + #include <dirent.h> ++#endif + + #include "iostream.hpp" + +@@ -33,6 +38,8 @@ + + namespace acommon { + ++#ifdef WIN32PORT ++#else + class Dir { + DIR * d_; + Dir(const Dir &); +@@ -42,6 +49,7 @@ + Dir(DIR * d) : d_(d) {} + ~Dir() {if (d_) closedir(d_);} + }; ++#endif + + ///////////////////////////////////////////////////////////////// + // +@@ -51,15 +59,26 @@ + static void get_data_dirs (Config *, + StringList &); + +- struct DictExt ++ struct ASPELL_API DictExt + { ++#ifdef WIN32PORT ++ static const size_t max_ext_size; // FB = 15; ++#else + static const size_t max_ext_size = 15; ++#endif + const ModuleInfo * module; + size_t ext_size; ++#ifdef WIN32PORT ++ char ext[15 + 1]; //FB ++#else + char ext[max_ext_size + 1]; ++#endif + DictExt(ModuleInfo * m, const char * e); + }; + ++#ifdef WIN32PORT ++ const size_t DictExt::max_ext_size = 15; // FB ++#endif + typedef Vector<DictExt> DictExtList; + + struct MDInfoListAll +@@ -77,8 +96,15 @@ + void fill_helper_lists(const StringList &); + }; + ++#ifdef WIN32PORT ++ class ASPELL_API MDInfoListofLists // FB ++#else + struct MDInfoListofLists ++#endif + { ++#ifdef WIN32PORT ++ public://FB ++#endif + MDInfoListAll * data; + + int offset; +@@ -112,7 +138,7 @@ + // Built in modules + // + +- struct ModuleInfoDefItem { ++ struct ASPELL_API ModuleInfoDefItem { + const char * name; + const char * data; + }; +@@ -163,12 +189,32 @@ + StringListEnumeration els = list_all.for_dirs.elements_obj(); + const char * dir; + while ( (dir = els.next()) != 0) { ++#ifdef WIN32PORT ++ int length = strlen(dir); ++ char *buff = new char[length + 3]; ++ strcpy(buff, dir); ++ buff[length] = '\\'; ++ buff[length+1] = '*'; ++ buff[length+2] = '\0'; ++ ++ WIN32_FIND_DATA fd; //FB ++ HANDLE hFile = FindFirstFile( buff/*dir*/,&fd ); //FB ++ ++ if (hFile == INVALID_HANDLE_VALUE){ ++ DWORD dw = GetLastError(); ++ continue; // FB ++ } ++ while(FindNextFile(hFile, &fd) != 0) { // FB ++ ++ const char * name = fd.cFileName; // FB ++#else + Dir d(opendir(dir)); + if (d==0) continue; + + struct dirent * entry; + while ( (entry = readdir(d)) != 0) { + const char * name = entry->d_name; ++#endif + const char * dot_loc = strrchr(name, '.'); + unsigned int name_size = dot_loc == 0 ? strlen(name) : dot_loc - name; + +@@ -184,6 +230,10 @@ + RET_ON_ERR(in.open(path, "r")); + RET_ON_ERR(proc_info(list_all, config, name, name_size, in)); + } ++#ifdef WIN32PORT ++ FindClose(hFile); // FB ++ delete[] buff; ++#endif + } + return no_err; + } +@@ -292,12 +342,30 @@ + StringListEnumeration els = list_all.dict_dirs.elements_obj(); + const char * dir; + while ( (dir = els.next()) != 0) { ++#ifdef WIN32PORT ++ int length = strlen(dir); //FB ++ char *buff = new char[length + 3]; ++ strcpy(buff, dir); ++ buff[length] = '\\'; ++ buff[length+1] = '*'; ++ buff[length+2] = '\0'; ++ ++ WIN32_FIND_DATA fd; //FB ++ HANDLE hFile = FindFirstFile( /*dir*/buff,&fd ); //FB ++ delete[] buff;//FB ++ if (hFile == INVALID_HANDLE_VALUE) continue; // FB ++ ++ while(FindNextFile(hFile, &fd) != 0) { // FB ++ ++ const char * name = fd.cFileName; // FB ++#else + Dir d(opendir(dir)); + if (d==0) continue; + + struct dirent * entry; + while ( (entry = readdir(d)) != 0) { + const char * name = entry->d_name; ++#endif + unsigned int name_size = strlen(name); + + DictExtList::const_iterator i = list_all.dict_exts.begin(); +diff -rubw aspell-0.50.4.1/common/info.hpp aspell-win32/common/info.hpp +--- aspell-0.50.4.1/common/info.hpp 2002-07-24 00:32:54.000000000 -0400 ++++ aspell-win32/common/info.hpp 2004-01-06 15:29:43.000000000 -0500 +@@ -7,6 +7,9 @@ + #ifndef ASPELL_INFO__HPP + #define ASPELL_INFO__HPP + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "posib_err.hpp" + #include "type_id.hpp" + +@@ -25,7 +28,7 @@ + struct StringListImpl; + class FStream; + +- struct ModuleInfo { ++ struct ASPELL_API ModuleInfo { + const char * name; + double order_num; + const char * lib_dir; +@@ -36,7 +39,7 @@ + PosibErr<void> get_dict_file_name(const DictInfo *, + String & main_wl, String & flags); + +- struct DictInfo { ++ struct ASPELL_API DictInfo { + const char * name; + const char * code; + const char * jargon; +@@ -49,7 +52,7 @@ + + struct ModuleInfoNode; + +- class ModuleInfoList { ++ class ASPELL_API ModuleInfoList { + public: + ModuleInfoList() : size_(0), head_(0) {} + void clear(); +@@ -73,7 +76,7 @@ + + struct DictInfoNode; + +- class DictInfoList { ++ class ASPELL_API DictInfoList { + public: + DictInfoList() : size_(0), head_(0) {} + void clear(); +@@ -92,9 +95,9 @@ + DictInfoNode * head_; + }; + +- DictInfoList * get_dict_info_list(Config *); ++ ASPELL_API DictInfoList * get_dict_info_list(Config *); + +- class ModuleInfoEnumeration { ++ class ASPELL_API ModuleInfoEnumeration { + public: + typedef const ModuleInfo * Value; + +@@ -116,7 +119,7 @@ + + struct DictInfoNode; + +- class DictInfoEnumeration { ++ class ASPELL_API DictInfoEnumeration { + public: + const DictInfoNode * node_; + DictInfoEnumeration(const DictInfoNode * n) : node_(n) {} +diff -rubw aspell-0.50.4.1/common/iostream.cpp aspell-win32/common/iostream.cpp +--- aspell-0.50.4.1/common/iostream.cpp 2002-09-18 09:38:08.000000000 -0400 ++++ aspell-win32/common/iostream.cpp 2004-01-06 15:29:45.000000000 -0500 +@@ -5,9 +5,13 @@ + // it at http://www.gnu.org/. + + #include "iostream.hpp" ++#ifdef WIN32PORT ++#include "settings.h" ++#include "aspellroot.h" ++#endif + + namespace acommon { +- FStream CIN(stdin, false); +- FStream COUT(stdout, false); +- FStream CERR(stderr, false); ++ FStream DLLIMPORT CIN(stdin, false); ++ FStream DLLIMPORT COUT(stdout, false); ++ FStream DLLIMPORT CERR(stderr, false); + } +diff -rubw aspell-0.50.4.1/common/iostream.hpp aspell-win32/common/iostream.hpp +--- aspell-0.50.4.1/common/iostream.hpp 2002-11-25 19:21:50.000000000 -0500 ++++ aspell-win32/common/iostream.hpp 2004-01-06 15:29:47.000000000 -0500 +@@ -9,11 +9,15 @@ + + #include "fstream.hpp" + ++#ifdef WIN32PORT ++#define DLLIMPORT ASPELL_API ++#else + #if defined(__CYGWIN__) + #define DLLIMPORT __declspec(dllimport) + #else + #define DLLIMPORT + #endif ++#endif + + namespace acommon { + +diff -rubw aspell-0.50.4.1/common/istream.hpp aspell-win32/common/istream.hpp +--- aspell-0.50.4.1/common/istream.hpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/istream.hpp 2004-01-06 15:29:48.000000000 -0500 +@@ -8,12 +8,15 @@ + #define ASPELL_ISTREAM__HPP + + #include <string.h> ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + namespace acommon { + + class String; + +- class IStream { ++ class ASPELL_API IStream { + private: + char delem; + public: +diff -rubw aspell-0.50.4.1/common/ostream.hpp aspell-win32/common/ostream.hpp +--- aspell-0.50.4.1/common/ostream.hpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/ostream.hpp 2004-01-06 15:29:50.000000000 -0500 +@@ -8,10 +8,13 @@ + #define ASPELL_OSTREAM__HPP + + #include "parm_string.hpp" ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + namespace acommon { + +- class OStream { ++ class ASPELL_API OStream { + public: + virtual void write (char c) = 0; + virtual void write (ParmString) = 0; +diff -rubw aspell-0.50.4.1/common/parm_string.hpp aspell-win32/common/parm_string.hpp +--- aspell-0.50.4.1/common/parm_string.hpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/parm_string.hpp 2004-01-06 15:29:53.000000000 -0500 +@@ -9,6 +9,9 @@ + + #include <string.h> + #include <limits.h> ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + // + // ParmString is a special string class that is designed to be used as +@@ -37,7 +40,7 @@ + + class String; + +- class ParmString { ++ class ASPELL_API ParmString { + public: + ParmString() : str_(0) {} + ParmString(const char * str, unsigned int sz = UINT_MAX) +diff -rubw aspell-0.50.4.1/common/posib_err.cpp aspell-win32/common/posib_err.cpp +--- aspell-0.50.4.1/common/posib_err.cpp 2002-11-29 02:14:36.000000000 -0500 ++++ aspell-win32/common/posib_err.cpp 2004-01-06 15:29:57.000000000 -0500 +@@ -9,12 +9,19 @@ + #include <assert.h> + + #include "posib_err.hpp" ++#ifdef WIN32PORT ++using namespace std; // FB ++#endif + + namespace acommon { + + String & String::operator= (const PosibErr<String> & s) + { ++#ifdef WIN32PORT ++ string::operator=(s.data); //FB ++#else + std::string::operator=(s.data); ++#endif + return *this; + } + +diff -rubw aspell-0.50.4.1/common/posib_err.hpp aspell-win32/common/posib_err.hpp +--- aspell-0.50.4.1/common/posib_err.hpp 2003-01-22 22:27:16.000000000 -0500 ++++ aspell-win32/common/posib_err.hpp 2004-01-06 15:30:07.000000000 -0500 +@@ -9,6 +9,10 @@ + + #include "string.hpp" + #include "error.hpp" ++#ifdef WIN32PORT ++#include "aspellroot.h" ++using namespace std; // FB ++#endif + + namespace acommon { + +@@ -30,7 +34,7 @@ + + template <typename Ret> class PosibErr; + +- class PosibErrBase { ++ class ASPELL_API PosibErrBase { + private: + struct ErrPtr { + const Error * err; +@@ -202,12 +206,19 @@ + // + // + ++#ifdef WIN32PORT ++#else + inline String::String(const PosibErr<String> & other) + : std::string(other.data) {} ++#endif + + inline String & String::operator= (const PosibErr<const char *> & s) + { ++#ifdef WIN32PORT ++ string::operator=(s.data); // FB ++#else + std::string::operator=(s.data); ++#endif + return *this; + } + +diff -rubw aspell-0.50.4.1/common/speller.hpp aspell-win32/common/speller.hpp +--- aspell-0.50.4.1/common/speller.hpp 2002-08-15 20:12:50.000000000 -0400 ++++ aspell-win32/common/speller.hpp 2004-01-16 08:50:39.000000000 -0500 +@@ -15,6 +15,9 @@ + #ifndef ASPELL_SPELLER__HPP + #define ASPELL_SPELLER__HPP + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "can_have_error.hpp" + #include "copy_ptr.hpp" + #include "clone_ptr.hpp" +@@ -103,10 +106,10 @@ + + // This function is current a hack to reload the filters in the + // speller class. I hope to eventually find a better way. +- PosibErr<void> reload_filters(Speller * m); ++ ASPELL_API PosibErr<void> reload_filters(Speller * m); + + +- PosibErr<Speller *> new_speller(Config * c); ++ ASPELL_API PosibErr<Speller *> new_speller(Config * c); + + } + +diff -rubw aspell-0.50.4.1/common/stack_ptr.hpp aspell-win32/common/stack_ptr.hpp +--- aspell-0.50.4.1/common/stack_ptr.hpp 2002-08-11 09:58:30.000000000 -0400 ++++ aspell-win32/common/stack_ptr.hpp 2004-01-06 15:30:11.000000000 -0500 +@@ -21,9 +21,12 @@ + // PosibErr<StackPtr<T > > pe = fun(); + // and operator* and StackPtr(T *) will be used. The explicit + // doesn't protect us here due to PosibErr ++#ifdef WIN32PORT ++#else + StackPtr(const StackPtr & other); + // becuase I am paranoid + StackPtr & operator=(const StackPtr & other); ++#endif + + public: + +diff -rubw aspell-0.50.4.1/common/string.hpp aspell-win32/common/string.hpp +--- aspell-0.50.4.1/common/string.hpp 2002-11-25 16:04:00.000000000 -0500 ++++ aspell-win32/common/string.hpp 2004-01-06 15:30:15.000000000 -0500 +@@ -14,6 +14,10 @@ + #include "parm_string.hpp" + #include "istream.hpp" + #include "ostream.hpp" ++#ifdef WIN32PORT ++#include "aspellroot.h" ++using namespace std; // FB ++#endif + + namespace acommon { + +@@ -22,6 +26,16 @@ + class String : public std::string, public OStream + { + public: ++#ifdef WIN32PORT ++ ASPELL_API String() : string() {} ++ ASPELL_API String(const char * s) : string(s) {} ++ ASPELL_API String(const char * s, unsigned int size) : string(s, size) {} ++ ASPELL_API String(ParmString s) : string(s) {} ++ ASPELL_API String(const std::string & s) : string(s) {} ++ ASPELL_API String(const String & other) : string(other) {} ++ ASPELL_API String & operator= (const char * s) { ++ string::operator= (s); ++#else + String() : std::string() {} + String(const char * s) : std::string(s) {} + String(const char * s, unsigned int size) : std::string(s, size) {} +@@ -31,30 +45,43 @@ + inline String(const PosibErr<String> & other); + String & operator= (const char * s) { + std::string::operator= (s); ++#endif + return *this; + } + inline String & operator= (const PosibErr<const char *> & s); +- String & operator= (ParmString s) { ++ ASPELL_API String & operator= (ParmString s) { ++#ifdef WIN32PORT ++ string::operator= (s); ++#else + std::string::operator= (s); ++#endif + return *this; + } +- String & operator= (const std::string & s) { ++ ASPELL_API String & operator= (const std::string & s) { ++#ifdef WIN32PORT ++ string::operator= (s); ++#else + std::string::operator= (s); ++#endif + return *this; + } +- String & operator= (const String & other) { ++ ASPELL_API String & operator= (const String & other) { ++#ifdef WIN32PORT ++ string::operator= (other); ++#else + std::string::operator= (other); ++#endif + return *this; + } +- /*inline*/ String & operator= (const PosibErr<String> & s); ++ ASPELL_API /*inline*/ String & operator= (const PosibErr<String> & s); + + ~String() {} + +- void clear() {*this = "";} ++ void ASPELL_API clear() {*this = "";} + +- void write (char c); +- void write (ParmString); +- void write (const char *, unsigned int); ++ void ASPELL_API write (char c); ++ void ASPELL_API write (ParmString); ++ void ASPELL_API write (const char *, unsigned int); + }; + + inline String operator+ (ParmString rhs, ParmString lhs) +diff -rubw aspell-0.50.4.1/common/string_buffer.cpp aspell-win32/common/string_buffer.cpp +--- aspell-0.50.4.1/common/string_buffer.cpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/string_buffer.cpp 2004-01-06 15:30:17.000000000 -0500 +@@ -17,7 +17,11 @@ + } + + char * StringBuffer::alloc(unsigned int size) { ++#if WIN32PORT ++ if (fill + size > get_buf_size()) { ++#else + if (fill + size > buf_size) { ++#endif + fill = 1; + bufs.push_front(sbuf); + } +diff -rubw aspell-0.50.4.1/common/string_buffer.hpp aspell-win32/common/string_buffer.hpp +--- aspell-0.50.4.1/common/string_buffer.hpp 2001-11-29 22:55:46.000000000 -0500 ++++ aspell-win32/common/string_buffer.hpp 2004-01-06 15:30:19.000000000 -0500 +@@ -10,10 +10,20 @@ + + class StringBuffer { + public: // but dont use ++#ifdef WIN32PORT ++#else + static const unsigned int buf_size = 1024 - 16; ++#endif + struct Buf { ++#ifdef WIN32PORT ++ char buf[1024 - 16]; // FB ++#else + char buf[buf_size]; ++#endif + }; ++#ifdef WIN32PORT ++ unsigned int get_buf_size(){ return 1024 - 16; } //FB ++#endif + private: + static const Buf sbuf; + BasicList<Buf> bufs; +diff -rubw aspell-0.50.4.1/common/string_list.hpp aspell-win32/common/string_list.hpp +--- aspell-0.50.4.1/common/string_list.hpp 2002-08-12 20:10:18.000000000 -0400 ++++ aspell-win32/common/string_list.hpp 2004-01-02 12:42:18.000000000 -0500 +@@ -55,18 +55,18 @@ + void destroy(); + public: + friend bool operator==(const StringList &, const StringList &); +- StringList() : first(0) {} +- StringList(const StringList & other) ++ ASPELL_API StringList() : first(0) {} ++ ASPELL_API StringList(const StringList & other) + { + copy(other); + } +- StringList & operator= (const StringList & other) ++ ASPELL_API StringList & operator= (const StringList & other) + { + destroy(); + copy(other); + return *this; + } +- virtual ~StringList() ++ ASPELL_API virtual ~StringList() + { + destroy(); + } +diff -rubw aspell-0.50.4.1/common/string_map.hpp aspell-win32/common/string_map.hpp +--- aspell-0.50.4.1/common/string_map.hpp 2002-08-12 20:10:18.000000000 -0400 ++++ aspell-win32/common/string_map.hpp 2004-01-06 15:30:21.000000000 -0500 +@@ -7,6 +7,9 @@ + #ifndef ASPELL_STRING_MAP__HPP + #define ASPELL_STRING_MAP__HPP + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "mutable_container.hpp" + #include "parm_string.hpp" + #include "posib_err.hpp" +@@ -49,7 +52,7 @@ + + // insert a new element. Will NOT overright an existing entry. + // returns false if the element already exists. +- bool insert(ParmString key, ParmString value) { ++ bool ASPELL_API insert(ParmString key, ParmString value) { + return insert(key, value, false); + } + PosibErr<bool> add(ParmString key) { +@@ -69,7 +72,7 @@ + // looks up an element. Returns null if the element did not exist. + // returns an empty string if the element exists but has a null value + // otherwise returns the value +- const char * lookup(ParmString key) const; ++ ASPELL_API const char * lookup(ParmString key) const; + + bool have(ParmString key) const {return lookup(key) != 0;} + +@@ -81,7 +84,7 @@ + + // inserts an element the last paramerts conters if an + // existing element will be overwritten. +- bool insert(ParmString key, ParmString value, bool); ++ bool ASPELL_API insert(ParmString key, ParmString value, bool); + + // clears the hash table, does NOT delete the old one + void clear_table(const unsigned int * size); +@@ -97,7 +100,7 @@ + const unsigned int * buckets; + }; + +-StringMap * new_string_map(); ++ASPELL_API StringMap * new_string_map(); + + + } +diff -rubw aspell-0.50.4.1/common/tokenizer.hpp aspell-win32/common/tokenizer.hpp +--- aspell-0.50.4.1/common/tokenizer.hpp 2002-08-10 12:17:08.000000000 -0400 ++++ aspell-win32/common/tokenizer.hpp 2004-01-06 15:30:23.000000000 -0500 +@@ -9,6 +9,9 @@ + + #include "char_vector.hpp" + #include "filter_char.hpp" ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + namespace acommon { + +@@ -35,7 +38,11 @@ + void reset (FilterChar * in, FilterChar * stop); + bool at_end() const {return word_begin == word_end;} + ++#ifdef WIN32PORT ++ virtual bool advance(){return false;}; // returns false if there is nothing left ++#else + virtual bool advance() = 0; // returns false if there is nothing left ++#endif + + bool is_begin(unsigned char c) const + {return char_type_[c].begin;} +diff -rubw aspell-0.50.4.1/common/type_id.hpp aspell-win32/common/type_id.hpp +--- aspell-0.50.4.1/common/type_id.hpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/common/type_id.hpp 2004-01-06 15:30:25.000000000 -0500 +@@ -9,12 +9,15 @@ + #ifndef ASPELL_TYPE_ID__HPP + #define ASPELL_TYPE_ID__HPP + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "parm_string.hpp" + + namespace acommon { + + +-union TypeId { ++union ASPELL_API TypeId { + unsigned int num; + char str[4]; + TypeId(ParmString str); +diff -rubw aspell-0.50.4.1/common/vector.hpp aspell-win32/common/vector.hpp +--- aspell-0.50.4.1/common/vector.hpp 2003-01-13 06:11:02.000000000 -0500 ++++ aspell-win32/common/vector.hpp 2004-01-06 15:30:26.000000000 -0500 +@@ -8,6 +8,9 @@ + #define ACOMMON_VECTOR__HPP + + #include <vector> ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + namespace acommon + { +Only in aspell-win32/data: split.kbd +diff -rubw aspell-0.50.4.1/interfaces/cc/aspell.h aspell-win32/interfaces/cc/aspell.h +--- aspell-0.50.4.1/interfaces/cc/aspell.h 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/interfaces/cc/aspell.h 2004-01-16 08:50:34.000000000 -0500 +@@ -9,6 +9,15 @@ + #ifndef ASPELL_ASPELL__H + #define ASPELL_ASPELL__H + ++#ifdef WIN32PORT ++#ifdef ASPELL_EXPORTS ++#define ASPELL_API __declspec(dllexport) ++#else ++#define ASPELL_API __declspec(dllimport) ++#endif ++#else ++#define ASPELL_API ++#endif + #ifdef __cplusplus + extern "C" { + #endif +@@ -34,13 +43,13 @@ + typedef struct AspellMutableContainer AspellMutableContainer; + + +-int aspell_mutable_container_add(struct AspellMutableContainer * ths, const char * to_add); ++ASPELL_API int aspell_mutable_container_add(struct AspellMutableContainer * ths, const char * to_add); + +-int aspell_mutable_container_remove(struct AspellMutableContainer * ths, const char * to_rem); ++ASPELL_API int aspell_mutable_container_remove(struct AspellMutableContainer * ths, const char * to_rem); + +-void aspell_mutable_container_clear(struct AspellMutableContainer * ths); ++ASPELL_API void aspell_mutable_container_clear(struct AspellMutableContainer * ths); + +-struct AspellMutableContainer * aspell_mutable_container_to_mutable_container(struct AspellMutableContainer * ths); ++ASPELL_API struct AspellMutableContainer * aspell_mutable_container_to_mutable_container(struct AspellMutableContainer * ths); + + + +@@ -82,50 +91,50 @@ + typedef struct AspellKeyInfoEnumeration AspellKeyInfoEnumeration; + + +-int aspell_key_info_enumeration_at_end(const struct AspellKeyInfoEnumeration * ths); ++ASPELL_API int aspell_key_info_enumeration_at_end(const struct AspellKeyInfoEnumeration * ths); + +-const struct AspellKeyInfo * aspell_key_info_enumeration_next(struct AspellKeyInfoEnumeration * ths); ++ASPELL_API const struct AspellKeyInfo * aspell_key_info_enumeration_next(struct AspellKeyInfoEnumeration * ths); + +-void delete_aspell_key_info_enumeration(struct AspellKeyInfoEnumeration * ths); ++ASPELL_API void delete_aspell_key_info_enumeration(struct AspellKeyInfoEnumeration * ths); + +-struct AspellKeyInfoEnumeration * aspell_key_info_enumeration_clone(const struct AspellKeyInfoEnumeration * ths); ++ASPELL_API struct AspellKeyInfoEnumeration * aspell_key_info_enumeration_clone(const struct AspellKeyInfoEnumeration * ths); + +-void aspell_key_info_enumeration_assign(struct AspellKeyInfoEnumeration * ths, const struct AspellKeyInfoEnumeration * other); ++ASPELL_API void aspell_key_info_enumeration_assign(struct AspellKeyInfoEnumeration * ths, const struct AspellKeyInfoEnumeration * other); + + + + typedef struct AspellConfig AspellConfig; + + +-struct AspellConfig * new_aspell_config(); ++ASPELL_API struct AspellConfig * new_aspell_config(); + +-void delete_aspell_config(struct AspellConfig * ths); ++ASPELL_API void delete_aspell_config(struct AspellConfig * ths); + +-struct AspellConfig * aspell_config_clone(const struct AspellConfig * ths); ++ASPELL_API struct AspellConfig * aspell_config_clone(const struct AspellConfig * ths); + +-void aspell_config_assign(struct AspellConfig * ths, const struct AspellConfig * other); ++ASPELL_API void aspell_config_assign(struct AspellConfig * ths, const struct AspellConfig * other); + +-unsigned int aspell_config_error_number(const struct AspellConfig * ths); ++ASPELL_API unsigned int aspell_config_error_number(const struct AspellConfig * ths); + +-const char * aspell_config_error_message(const struct AspellConfig * ths); ++ASPELL_API const char * aspell_config_error_message(const struct AspellConfig * ths); + +-const struct AspellError * aspell_config_error(const struct AspellConfig * ths); ++ASPELL_API const struct AspellError * aspell_config_error(const struct AspellConfig * ths); + + /* sets extra keys which this config class should accept + * begin and end are expected to point to the begging + * and end of an array of Aspell Key Info */ +-void aspell_config_set_extra(struct AspellConfig * ths, const struct AspellKeyInfo * begin, const struct AspellKeyInfo * end); ++ASPELL_API void aspell_config_set_extra(struct AspellConfig * ths, const struct AspellKeyInfo * begin, const struct AspellKeyInfo * end); + + /* returns the KeyInfo object for the + * corresponding key or returns null and sets + * error_num to PERROR_UNKNOWN_KEY if the key is + * not valid. The pointer returned is valid for + * the lifetime of the object. */ +-const struct AspellKeyInfo * aspell_config_keyinfo(struct AspellConfig * ths, const char * key); ++ASPELL_API const struct AspellKeyInfo * aspell_config_keyinfo(struct AspellConfig * ths, const char * key); + + /* returns a newly allocated enumeration of all the + * possible objects this config class uses */ +-struct AspellKeyInfoEnumeration * aspell_config_possible_elements(struct AspellConfig * ths, int include_extra); ++ASPELL_API struct AspellKeyInfoEnumeration * aspell_config_possible_elements(struct AspellConfig * ths, int include_extra); + + /* returns the default value for given key which + * way involve substating variables, thus it is +@@ -133,12 +142,12 @@ + * and sets error_num to PERROR_UNKNOWN_KEY if + * the key is not valid. Uses the temporary + * string. */ +-const char * aspell_config_get_default(struct AspellConfig * ths, const char * key); ++ASPELL_API const char * aspell_config_get_default(struct AspellConfig * ths, const char * key); + + /* returns a newly alloacted enumeration of all the + * key/value pairs. This DOES not include ones + * which are set to their default values */ +-struct AspellStringPairEnumeration * aspell_config_elements(struct AspellConfig * ths); ++ASPELL_API struct AspellStringPairEnumeration * aspell_config_elements(struct AspellConfig * ths); + + /* inserts an item, if the item already exists it + * will be replaced. returns true if it succesed +@@ -150,7 +159,7 @@ + * PERROR_CANT_CHANGE_VALUE, and if the value is + * a list and you are trying to set it directory + * it sets error_num to PERROR_LIST_SET */ +-int aspell_config_replace(struct AspellConfig * ths, const char * key, const char * value); ++ASPELL_API int aspell_config_replace(struct AspellConfig * ths, const char * key, const char * value); + + /* remove a key and returns true if it exists + * otherise return false. This effictly sets the +@@ -162,20 +171,20 @@ + * PERROR_UNKNOWN_KEY, if the value can not be + * changed sets error_num to + * PERROR_CANT_CHANGE_VALUE */ +-int aspell_config_remove(struct AspellConfig * ths, const char * key); ++ASPELL_API int aspell_config_remove(struct AspellConfig * ths, const char * key); + +-int aspell_config_have(const struct AspellConfig * ths, const char * key); ++ASPELL_API int aspell_config_have(const struct AspellConfig * ths, const char * key); + + /* returns null on error */ +-const char * aspell_config_retrieve(struct AspellConfig * ths, const char * key); ++ASPELL_API const char * aspell_config_retrieve(struct AspellConfig * ths, const char * key); + +-int aspell_config_retrieve_list(struct AspellConfig * ths, const char * key, struct AspellMutableContainer * lst); ++ASPELL_API int aspell_config_retrieve_list(struct AspellConfig * ths, const char * key, struct AspellMutableContainer * lst); + + /* return -1 on error, 0 if false, 1 if true */ +-int aspell_config_retrieve_bool(struct AspellConfig * ths, const char * key); ++ASPELL_API int aspell_config_retrieve_bool(struct AspellConfig * ths, const char * key); + + /* return -1 on error */ +-int aspell_config_retrieve_int(struct AspellConfig * ths, const char * key); ++ASPELL_API int aspell_config_retrieve_int(struct AspellConfig * ths, const char * key); + + + +@@ -193,7 +202,7 @@ + + typedef struct AspellError AspellError; + +-int aspell_error_is_a(const struct AspellError * ths, const struct AspellErrorInfo * e); ++ASPELL_API int aspell_error_is_a(const struct AspellError * ths, const struct AspellErrorInfo * e); + + + struct AspellErrorInfo { +@@ -218,13 +227,13 @@ + typedef struct AspellCanHaveError AspellCanHaveError; + + +-unsigned int aspell_error_number(const struct AspellCanHaveError * ths); ++ASPELL_API unsigned int aspell_error_number(const struct AspellCanHaveError * ths); + +-const char * aspell_error_message(const struct AspellCanHaveError * ths); ++ASPELL_API const char * aspell_error_message(const struct AspellCanHaveError * ths); + +-const struct AspellError * aspell_error(const struct AspellCanHaveError * ths); ++ASPELL_API const struct AspellError * aspell_error(const struct AspellCanHaveError * ths); + +-void delete_aspell_can_have_error(struct AspellCanHaveError * ths); ++ASPELL_API void delete_aspell_can_have_error(struct AspellCanHaveError * ths); + + + +@@ -274,44 +283,44 @@ + typedef struct AspellSpeller AspellSpeller; + + +-struct AspellCanHaveError * new_aspell_speller(struct AspellConfig * config); ++ASPELL_API struct AspellCanHaveError * new_aspell_speller(struct AspellConfig * config); + +-struct AspellSpeller * to_aspell_speller(struct AspellCanHaveError * obj); ++ASPELL_API struct AspellSpeller * to_aspell_speller(struct AspellCanHaveError * obj); + +-void delete_aspell_speller(struct AspellSpeller * ths); ++ASPELL_API void delete_aspell_speller(struct AspellSpeller * ths); + +-unsigned int aspell_speller_error_number(const struct AspellSpeller * ths); ++ASPELL_API unsigned int aspell_speller_error_number(const struct AspellSpeller * ths); + +-const char * aspell_speller_error_message(const struct AspellSpeller * ths); ++ASPELL_API const char * aspell_speller_error_message(const struct AspellSpeller * ths); + +-const struct AspellError * aspell_speller_error(const struct AspellSpeller * ths); ++ASPELL_API const struct AspellError * aspell_speller_error(const struct AspellSpeller * ths); + +-struct AspellConfig * aspell_speller_config(struct AspellSpeller * ths); ++ASPELL_API struct AspellConfig * aspell_speller_config(struct AspellSpeller * ths); + + /* returns 0 if it is not in the dictionary, + * 1 if it is, or -1 on error. */ +-int aspell_speller_check(struct AspellSpeller * ths, const char * word, int word_size); ++ASPELL_API int aspell_speller_check(struct AspellSpeller * ths, const char * word, int word_size); + +-int aspell_speller_add_to_personal(struct AspellSpeller * ths, const char * word, int word_size); ++ASPELL_API int aspell_speller_add_to_personal(struct AspellSpeller * ths, const char * word, int word_size); + +-int aspell_speller_add_to_session(struct AspellSpeller * ths, const char * word, int word_size); ++ASPELL_API int aspell_speller_add_to_session(struct AspellSpeller * ths, const char * word, int word_size); + +-const struct AspellWordList * aspell_speller_personal_word_list(struct AspellSpeller * ths); ++ASPELL_API const struct AspellWordList * aspell_speller_personal_word_list(struct AspellSpeller * ths); + +-const struct AspellWordList * aspell_speller_session_word_list(struct AspellSpeller * ths); ++ASPELL_API const struct AspellWordList * aspell_speller_session_word_list(struct AspellSpeller * ths); + +-const struct AspellWordList * aspell_speller_main_word_list(struct AspellSpeller * ths); ++ASPELL_API const struct AspellWordList * aspell_speller_main_word_list(struct AspellSpeller * ths); + +-int aspell_speller_save_all_word_lists(struct AspellSpeller * ths); ++ASPELL_API int aspell_speller_save_all_word_lists(struct AspellSpeller * ths); + +-int aspell_speller_clear_session(struct AspellSpeller * ths); ++ASPELL_API int aspell_speller_clear_session(struct AspellSpeller * ths); + + /* Return null on error. + * the word list returned by suggest is only valid until the next + * call to suggest */ +-const struct AspellWordList * aspell_speller_suggest(struct AspellSpeller * ths, const char * word, int word_size); ++ASPELL_API const struct AspellWordList * aspell_speller_suggest(struct AspellSpeller * ths, const char * word, int word_size); + +-int aspell_speller_store_replacement(struct AspellSpeller * ths, const char * mis, int mis_size, const char * cor, int cor_size); ++ASPELL_API int aspell_speller_store_replacement(struct AspellSpeller * ths, const char * mis, int mis_size, const char * cor, int cor_size); + + + +@@ -321,15 +330,15 @@ + typedef struct AspellFilter AspellFilter; + + +-void delete_aspell_filter(struct AspellFilter * ths); ++ASPELL_API void delete_aspell_filter(struct AspellFilter * ths); + +-unsigned int aspell_filter_error_number(const struct AspellFilter * ths); ++ASPELL_API unsigned int aspell_filter_error_number(const struct AspellFilter * ths); + +-const char * aspell_filter_error_message(const struct AspellFilter * ths); ++ASPELL_API const char * aspell_filter_error_message(const struct AspellFilter * ths); + +-const struct AspellError * aspell_filter_error(const struct AspellFilter * ths); ++ASPELL_API const struct AspellError * aspell_filter_error(const struct AspellFilter * ths); + +-struct AspellFilter * to_aspell_filter(struct AspellCanHaveError * obj); ++ASPELL_API struct AspellFilter * to_aspell_filter(struct AspellCanHaveError * obj); + + + +@@ -351,13 +360,13 @@ + typedef struct AspellDocumentChecker AspellDocumentChecker; + + +-void delete_aspell_document_checker(struct AspellDocumentChecker * ths); ++ASPELL_API void delete_aspell_document_checker(struct AspellDocumentChecker * ths); + +-unsigned int aspell_document_checker_error_number(const struct AspellDocumentChecker * ths); ++ASPELL_API unsigned int aspell_document_checker_error_number(const struct AspellDocumentChecker * ths); + +-const char * aspell_document_checker_error_message(const struct AspellDocumentChecker * ths); ++ASPELL_API const char * aspell_document_checker_error_message(const struct AspellDocumentChecker * ths); + +-const struct AspellError * aspell_document_checker_error(const struct AspellDocumentChecker * ths); ++ASPELL_API const struct AspellError * aspell_document_checker_error(const struct AspellDocumentChecker * ths); + + /* Creates a new document checker. + * The speller class is expect to last until this +@@ -368,13 +377,13 @@ + * If filter is given then it will take ownership of + * the filter class and use it to do the filtering. + * You are expected to free the checker when done. */ +-struct AspellCanHaveError * new_aspell_document_checker(struct AspellSpeller * speller); ++ASPELL_API struct AspellCanHaveError * new_aspell_document_checker(struct AspellSpeller * speller); + +-struct AspellDocumentChecker * to_aspell_document_checker(struct AspellCanHaveError * obj); ++ASPELL_API struct AspellDocumentChecker * to_aspell_document_checker(struct AspellCanHaveError * obj); + + /* reset the internal state of the filter. + * should be called whenever a new document is being filtered */ +-void aspell_document_checker_reset(struct AspellDocumentChecker * ths); ++ASPELL_API void aspell_document_checker_reset(struct AspellDocumentChecker * ths); + + /* process a string + * The string passed in should only be split on white space +@@ -383,15 +392,15 @@ + * in the document. Passing in stings out of order, skipping + * strings or passing them in more than once may lead to undefined + * results. */ +-void aspell_document_checker_process(struct AspellDocumentChecker * ths, const char * str, int size); ++ASPELL_API void aspell_document_checker_process(struct AspellDocumentChecker * ths, const char * str, int size); + + /* returns the next misspelled word in the processed string + * if there are no more misspelled word than token.word + * will be null and token.size will be 0 */ +-struct AspellToken aspell_document_checker_next_misspelling(struct AspellDocumentChecker * ths); ++ASPELL_API struct AspellToken aspell_document_checker_next_misspelling(struct AspellDocumentChecker * ths); + + /* returns the underlying filter class */ +-struct AspellFilter * aspell_document_checker_filter(struct AspellDocumentChecker * ths); ++ASPELL_API struct AspellFilter * aspell_document_checker_filter(struct AspellDocumentChecker * ths); + + + +@@ -401,11 +410,11 @@ + typedef struct AspellWordList AspellWordList; + + +-int aspell_word_list_empty(const struct AspellWordList * ths); ++ASPELL_API int aspell_word_list_empty(const struct AspellWordList * ths); + +-unsigned int aspell_word_list_size(const struct AspellWordList * ths); ++ASPELL_API unsigned int aspell_word_list_size(const struct AspellWordList * ths); + +-struct AspellStringEnumeration * aspell_word_list_elements(const struct AspellWordList * ths); ++ASPELL_API struct AspellStringEnumeration * aspell_word_list_elements(const struct AspellWordList * ths); + + + +@@ -415,15 +424,15 @@ + typedef struct AspellStringEnumeration AspellStringEnumeration; + + +-void delete_aspell_string_enumeration(struct AspellStringEnumeration * ths); ++ASPELL_API void delete_aspell_string_enumeration(struct AspellStringEnumeration * ths); + +-struct AspellStringEnumeration * aspell_string_enumeration_clone(const struct AspellStringEnumeration * ths); ++ASPELL_API struct AspellStringEnumeration * aspell_string_enumeration_clone(const struct AspellStringEnumeration * ths); + +-void aspell_string_enumeration_assign(struct AspellStringEnumeration * ths, const struct AspellStringEnumeration * other); ++ASPELL_API void aspell_string_enumeration_assign(struct AspellStringEnumeration * ths, const struct AspellStringEnumeration * other); + +-int aspell_string_enumeration_at_end(const struct AspellStringEnumeration * ths); ++ASPELL_API int aspell_string_enumeration_at_end(const struct AspellStringEnumeration * ths); + +-const char * aspell_string_enumeration_next(struct AspellStringEnumeration * ths); ++ASPELL_API const char * aspell_string_enumeration_next(struct AspellStringEnumeration * ths); + + + +@@ -472,56 +481,56 @@ + typedef struct AspellModuleInfoList AspellModuleInfoList; + + +-struct AspellModuleInfoList * get_aspell_module_info_list(struct AspellConfig * config); ++ASPELL_API struct AspellModuleInfoList * get_aspell_module_info_list(struct AspellConfig * config); + +-int aspell_module_info_list_empty(const struct AspellModuleInfoList * ths); ++ASPELL_API int aspell_module_info_list_empty(const struct AspellModuleInfoList * ths); + +-unsigned int aspell_module_info_list_size(const struct AspellModuleInfoList * ths); ++ASPELL_API unsigned int aspell_module_info_list_size(const struct AspellModuleInfoList * ths); + +-struct AspellModuleInfoEnumeration * aspell_module_info_list_elements(const struct AspellModuleInfoList * ths); ++ASPELL_API struct AspellModuleInfoEnumeration * aspell_module_info_list_elements(const struct AspellModuleInfoList * ths); + + + + typedef struct AspellDictInfoList AspellDictInfoList; + + +-struct AspellDictInfoList * get_aspell_dict_info_list(struct AspellConfig * config); ++ASPELL_API struct AspellDictInfoList * get_aspell_dict_info_list(struct AspellConfig * config); + +-int aspell_dict_info_list_empty(const struct AspellDictInfoList * ths); ++ASPELL_API int aspell_dict_info_list_empty(const struct AspellDictInfoList * ths); + +-unsigned int aspell_dict_info_list_size(const struct AspellDictInfoList * ths); ++ASPELL_API unsigned int aspell_dict_info_list_size(const struct AspellDictInfoList * ths); + +-struct AspellDictInfoEnumeration * aspell_dict_info_list_elements(const struct AspellDictInfoList * ths); ++ASPELL_API struct AspellDictInfoEnumeration * aspell_dict_info_list_elements(const struct AspellDictInfoList * ths); + + + + typedef struct AspellModuleInfoEnumeration AspellModuleInfoEnumeration; + + +-int aspell_module_info_enumeration_at_end(const struct AspellModuleInfoEnumeration * ths); ++ASPELL_API int aspell_module_info_enumeration_at_end(const struct AspellModuleInfoEnumeration * ths); + +-const struct AspellModuleInfo * aspell_module_info_enumeration_next(struct AspellModuleInfoEnumeration * ths); ++ASPELL_API const struct AspellModuleInfo * aspell_module_info_enumeration_next(struct AspellModuleInfoEnumeration * ths); + +-void delete_aspell_module_info_enumeration(struct AspellModuleInfoEnumeration * ths); ++ASPELL_API void delete_aspell_module_info_enumeration(struct AspellModuleInfoEnumeration * ths); + +-struct AspellModuleInfoEnumeration * aspell_module_info_enumeration_clone(const struct AspellModuleInfoEnumeration * ths); ++ASPELL_API struct AspellModuleInfoEnumeration * aspell_module_info_enumeration_clone(const struct AspellModuleInfoEnumeration * ths); + +-void aspell_module_info_enumeration_assign(struct AspellModuleInfoEnumeration * ths, const struct AspellModuleInfoEnumeration * other); ++ASPELL_API void aspell_module_info_enumeration_assign(struct AspellModuleInfoEnumeration * ths, const struct AspellModuleInfoEnumeration * other); + + + + typedef struct AspellDictInfoEnumeration AspellDictInfoEnumeration; + + +-int aspell_dict_info_enumeration_at_end(const struct AspellDictInfoEnumeration * ths); ++ASPELL_API int aspell_dict_info_enumeration_at_end(const struct AspellDictInfoEnumeration * ths); + +-const struct AspellDictInfo * aspell_dict_info_enumeration_next(struct AspellDictInfoEnumeration * ths); ++ASPELL_API const struct AspellDictInfo * aspell_dict_info_enumeration_next(struct AspellDictInfoEnumeration * ths); + +-void delete_aspell_dict_info_enumeration(struct AspellDictInfoEnumeration * ths); ++ASPELL_API void delete_aspell_dict_info_enumeration(struct AspellDictInfoEnumeration * ths); + +-struct AspellDictInfoEnumeration * aspell_dict_info_enumeration_clone(const struct AspellDictInfoEnumeration * ths); ++ASPELL_API struct AspellDictInfoEnumeration * aspell_dict_info_enumeration_clone(const struct AspellDictInfoEnumeration * ths); + +-void aspell_dict_info_enumeration_assign(struct AspellDictInfoEnumeration * ths, const struct AspellDictInfoEnumeration * other); ++ASPELL_API void aspell_dict_info_enumeration_assign(struct AspellDictInfoEnumeration * ths, const struct AspellDictInfoEnumeration * other); + + + +@@ -531,27 +540,27 @@ + typedef struct AspellStringList AspellStringList; + + +-struct AspellStringList * new_aspell_string_list(); ++ASPELL_API struct AspellStringList * new_aspell_string_list(); + +-int aspell_string_list_empty(const struct AspellStringList * ths); ++ASPELL_API int aspell_string_list_empty(const struct AspellStringList * ths); + +-unsigned int aspell_string_list_size(const struct AspellStringList * ths); ++ASPELL_API unsigned int aspell_string_list_size(const struct AspellStringList * ths); + +-struct AspellStringEnumeration * aspell_string_list_elements(const struct AspellStringList * ths); ++ASPELL_API struct AspellStringEnumeration * aspell_string_list_elements(const struct AspellStringList * ths); + +-int aspell_string_list_add(struct AspellStringList * ths, const char * to_add); ++ASPELL_API int aspell_string_list_add(struct AspellStringList * ths, const char * to_add); + +-int aspell_string_list_remove(struct AspellStringList * ths, const char * to_rem); ++ASPELL_API int aspell_string_list_remove(struct AspellStringList * ths, const char * to_rem); + +-void aspell_string_list_clear(struct AspellStringList * ths); ++ASPELL_API void aspell_string_list_clear(struct AspellStringList * ths); + +-struct AspellMutableContainer * aspell_string_list_to_mutable_container(struct AspellStringList * ths); ++ASPELL_API struct AspellMutableContainer * aspell_string_list_to_mutable_container(struct AspellStringList * ths); + +-void delete_aspell_string_list(struct AspellStringList * ths); ++ASPELL_API void delete_aspell_string_list(struct AspellStringList * ths); + +-struct AspellStringList * aspell_string_list_clone(const struct AspellStringList * ths); ++ASPELL_API struct AspellStringList * aspell_string_list_clone(const struct AspellStringList * ths); + +-void aspell_string_list_assign(struct AspellStringList * ths, const struct AspellStringList * other); ++ASPELL_API void aspell_string_list_assign(struct AspellStringList * ths, const struct AspellStringList * other); + + + +@@ -561,43 +570,43 @@ + typedef struct AspellStringMap AspellStringMap; + + +-struct AspellStringMap * new_aspell_string_map(); ++ASPELL_API struct AspellStringMap * new_aspell_string_map(); + +-int aspell_string_map_add(struct AspellStringMap * ths, const char * to_add); ++ASPELL_API int aspell_string_map_add(struct AspellStringMap * ths, const char * to_add); + +-int aspell_string_map_remove(struct AspellStringMap * ths, const char * to_rem); ++ASPELL_API int aspell_string_map_remove(struct AspellStringMap * ths, const char * to_rem); + +-void aspell_string_map_clear(struct AspellStringMap * ths); ++ASPELL_API void aspell_string_map_clear(struct AspellStringMap * ths); + +-struct AspellMutableContainer * aspell_string_map_to_mutable_container(struct AspellStringMap * ths); ++ASPELL_API struct AspellMutableContainer * aspell_string_map_to_mutable_container(struct AspellStringMap * ths); + +-void delete_aspell_string_map(struct AspellStringMap * ths); ++ASPELL_API void delete_aspell_string_map(struct AspellStringMap * ths); + +-struct AspellStringMap * aspell_string_map_clone(const struct AspellStringMap * ths); ++ASPELL_API struct AspellStringMap * aspell_string_map_clone(const struct AspellStringMap * ths); + +-void aspell_string_map_assign(struct AspellStringMap * ths, const struct AspellStringMap * other); ++ASPELL_API void aspell_string_map_assign(struct AspellStringMap * ths, const struct AspellStringMap * other); + +-int aspell_string_map_empty(const struct AspellStringMap * ths); ++ASPELL_API int aspell_string_map_empty(const struct AspellStringMap * ths); + +-unsigned int aspell_string_map_size(const struct AspellStringMap * ths); ++ASPELL_API unsigned int aspell_string_map_size(const struct AspellStringMap * ths); + +-struct AspellStringPairEnumeration * aspell_string_map_elements(const struct AspellStringMap * ths); ++ASPELL_API struct AspellStringPairEnumeration * aspell_string_map_elements(const struct AspellStringMap * ths); + + /* Insert a new element. + * Will NOT overright an existing entry. + * Returns false if the element already exists. */ +-int aspell_string_map_insert(struct AspellStringMap * ths, const char * key, const char * value); ++ASPELL_API int aspell_string_map_insert(struct AspellStringMap * ths, const char * key, const char * value); + + /* Insert a new element. + * Will overright an existing entry. + * Always returns true. */ +-int aspell_string_map_replace(struct AspellStringMap * ths, const char * key, const char * value); ++ASPELL_API int aspell_string_map_replace(struct AspellStringMap * ths, const char * key, const char * value); + + /* Looks up an element. + * Returns null if the element did not exist. + * Returns an empty string if the element exists but has a null value. + * Otherwises returns the value */ +-const char * aspell_string_map_lookup(const struct AspellStringMap * ths, const char * key); ++ASPELL_API const char * aspell_string_map_lookup(const struct AspellStringMap * ths, const char * key); + + + +@@ -622,15 +631,15 @@ + typedef struct AspellStringPairEnumeration AspellStringPairEnumeration; + + +-int aspell_string_pair_enumeration_at_end(const struct AspellStringPairEnumeration * ths); ++ASPELL_API int aspell_string_pair_enumeration_at_end(const struct AspellStringPairEnumeration * ths); + +-struct AspellStringPair aspell_string_pair_enumeration_next(struct AspellStringPairEnumeration * ths); ++ASPELL_API struct AspellStringPair aspell_string_pair_enumeration_next(struct AspellStringPairEnumeration * ths); + +-void delete_aspell_string_pair_enumeration(struct AspellStringPairEnumeration * ths); ++ASPELL_API void delete_aspell_string_pair_enumeration(struct AspellStringPairEnumeration * ths); + +-struct AspellStringPairEnumeration * aspell_string_pair_enumeration_clone(const struct AspellStringPairEnumeration * ths); ++ASPELL_API struct AspellStringPairEnumeration * aspell_string_pair_enumeration_clone(const struct AspellStringPairEnumeration * ths); + +-void aspell_string_pair_enumeration_assign(struct AspellStringPairEnumeration * ths, const struct AspellStringPairEnumeration * other); ++ASPELL_API void aspell_string_pair_enumeration_assign(struct AspellStringPairEnumeration * ths, const struct AspellStringPairEnumeration * other); + + + +diff -rubw aspell-0.50.4.1/lib/can_have_error-c.cpp aspell-win32/lib/can_have_error-c.cpp +--- aspell-0.50.4.1/lib/can_have_error-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/can_have_error-c.cpp 2004-01-06 15:30:29.000000000 -0500 +@@ -6,6 +6,9 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "can_have_error.hpp" + #include "error.hpp" + +@@ -14,22 +17,22 @@ + class CanHaveError; + struct Error; + +-extern "C" unsigned int aspell_error_number(const CanHaveError * ths) ++extern "C" ASPELL_API unsigned int aspell_error_number(const CanHaveError * ths) + { + return ths->err_ == 0 ? 0 : 1; + } + +-extern "C" const char * aspell_error_message(const CanHaveError * ths) ++extern "C" ASPELL_API const char * aspell_error_message(const CanHaveError * ths) + { + return ths->err_ ? ths->err_->mesg : ""; + } + +-extern "C" const Error * aspell_error(const CanHaveError * ths) ++extern "C" ASPELL_API const Error * aspell_error(const CanHaveError * ths) + { + return ths->err_; + } + +-extern "C" void delete_aspell_can_have_error(CanHaveError * ths) ++extern "C" ASPELL_API void delete_aspell_can_have_error(CanHaveError * ths) + { + delete ths; + } +diff -rubw aspell-0.50.4.1/lib/config-c.cpp aspell-win32/lib/config-c.cpp +--- aspell-0.50.4.1/lib/config-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/config-c.cpp 2004-01-06 15:30:32.000000000 -0500 +@@ -6,6 +6,10 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#include "settings.h" ++#endif + #include "config.hpp" + #include "error.hpp" + #include "posib_err.hpp" +@@ -20,72 +24,72 @@ + class MutableContainer; + class StringPairEnumeration; + +-extern "C" int aspell_key_info_enumeration_at_end(const KeyInfoEnumeration * ths) ++extern "C" ASPELL_API int aspell_key_info_enumeration_at_end(const KeyInfoEnumeration * ths) + { + return ths->at_end(); + } + +-extern "C" const KeyInfo * aspell_key_info_enumeration_next(KeyInfoEnumeration * ths) ++extern "C" ASPELL_API const KeyInfo * aspell_key_info_enumeration_next(KeyInfoEnumeration * ths) + { + return ths->next(); + } + +-extern "C" void delete_aspell_key_info_enumeration(KeyInfoEnumeration * ths) ++extern "C" ASPELL_API void delete_aspell_key_info_enumeration(KeyInfoEnumeration * ths) + { + delete ths; + } + +-extern "C" KeyInfoEnumeration * aspell_key_info_enumeration_clone(const KeyInfoEnumeration * ths) ++extern "C" ASPELL_API KeyInfoEnumeration * aspell_key_info_enumeration_clone(const KeyInfoEnumeration * ths) + { + return ths->clone(); + } + +-extern "C" void aspell_key_info_enumeration_assign(KeyInfoEnumeration * ths, const KeyInfoEnumeration * other) ++extern "C" ASPELL_API void aspell_key_info_enumeration_assign(KeyInfoEnumeration * ths, const KeyInfoEnumeration * other) + { + ths->assign(other); + } + +-extern "C" Config * new_aspell_config() ++extern "C" ASPELL_API Config * new_aspell_config() + { + return new_config(); + } + +-extern "C" void delete_aspell_config(Config * ths) ++extern "C" ASPELL_API void delete_aspell_config(Config * ths) + { + delete ths; + } + +-extern "C" Config * aspell_config_clone(const Config * ths) ++extern "C" ASPELL_API Config * aspell_config_clone(const Config * ths) + { + return ths->clone(); + } + +-extern "C" void aspell_config_assign(Config * ths, const Config * other) ++extern "C" ASPELL_API void aspell_config_assign(Config * ths, const Config * other) + { + ths->assign(other); + } + +-extern "C" unsigned int aspell_config_error_number(const Config * ths) ++extern "C" ASPELL_API unsigned int aspell_config_error_number(const Config * ths) + { + return ths->err_ == 0 ? 0 : 1; + } + +-extern "C" const char * aspell_config_error_message(const Config * ths) ++extern "C" ASPELL_API const char * aspell_config_error_message(const Config * ths) + { + return ths->err_ ? ths->err_->mesg : ""; + } + +-extern "C" const Error * aspell_config_error(const Config * ths) ++extern "C" ASPELL_API const Error * aspell_config_error(const Config * ths) + { + return ths->err_; + } + +-extern "C" void aspell_config_set_extra(Config * ths, const KeyInfo * begin, const KeyInfo * end) ++extern "C" ASPELL_API void aspell_config_set_extra(Config * ths, const KeyInfo * begin, const KeyInfo * end) + { + ths->set_extra(begin, end); + } + +-extern "C" const KeyInfo * aspell_config_keyinfo(Config * ths, const char * key) ++extern "C" ASPELL_API const KeyInfo * aspell_config_keyinfo(Config * ths, const char * key) + { + PosibErr<const KeyInfo *> ret = ths->keyinfo(key); + ths->err_.reset(ret.release_err()); +@@ -93,12 +97,16 @@ + return ret.data; + } + +-extern "C" KeyInfoEnumeration * aspell_config_possible_elements(Config * ths, int include_extra) ++extern "C" ASPELL_API KeyInfoEnumeration * aspell_config_possible_elements(Config * ths, int include_extra) + { ++#ifdef WIN32PORT ++ return ths->possible_elements(include_extra != 0);//FB ++#else + return ths->possible_elements(include_extra); ++#endif + } + +-extern "C" const char * aspell_config_get_default(Config * ths, const char * key) ++extern "C" ASPELL_API const char * aspell_config_get_default(Config * ths, const char * key) + { + PosibErr<String> ret = ths->get_default(key); + ths->err_.reset(ret.release_err()); +@@ -107,12 +115,12 @@ + return ths->temp_str.c_str(); + } + +-extern "C" StringPairEnumeration * aspell_config_elements(Config * ths) ++extern "C" ASPELL_API StringPairEnumeration * aspell_config_elements(Config * ths) + { + return ths->elements(); + } + +-extern "C" int aspell_config_replace(Config * ths, const char * key, const char * value) ++extern "C" ASPELL_API int aspell_config_replace(Config * ths, const char * key, const char * value) + { + PosibErr<void> ret = ths->replace(key, value); + ths->err_.reset(ret.release_err()); +@@ -120,7 +128,7 @@ + return 1; + } + +-extern "C" int aspell_config_remove(Config * ths, const char * key) ++extern "C" ASPELL_API int aspell_config_remove(Config * ths, const char * key) + { + PosibErr<void> ret = ths->remove(key); + ths->err_.reset(ret.release_err()); +@@ -128,12 +136,12 @@ + return 1; + } + +-extern "C" int aspell_config_have(const Config * ths, const char * key) ++extern "C" ASPELL_API int aspell_config_have(const Config * ths, const char * key) + { + return ths->have(key); + } + +-extern "C" const char * aspell_config_retrieve(Config * ths, const char * key) ++extern "C" ASPELL_API const char * aspell_config_retrieve(Config * ths, const char * key) + { + PosibErr<String> ret = ths->retrieve(key); + ths->err_.reset(ret.release_err()); +@@ -142,7 +150,7 @@ + return ths->temp_str.c_str(); + } + +-extern "C" int aspell_config_retrieve_list(Config * ths, const char * key, MutableContainer * lst) ++extern "C" ASPELL_API int aspell_config_retrieve_list(Config * ths, const char * key, MutableContainer * lst) + { + PosibErr<void> ret = ths->retrieve_list(key, lst); + ths->err_.reset(ret.release_err()); +@@ -150,7 +158,7 @@ + return 1; + } + +-extern "C" int aspell_config_retrieve_bool(Config * ths, const char * key) ++extern "C" ASPELL_API int aspell_config_retrieve_bool(Config * ths, const char * key) + { + PosibErr<bool> ret = ths->retrieve_bool(key); + ths->err_.reset(ret.release_err()); +@@ -158,7 +166,7 @@ + return ret.data; + } + +-extern "C" int aspell_config_retrieve_int(Config * ths, const char * key) ++extern "C" ASPELL_API int aspell_config_retrieve_int(Config * ths, const char * key) + { + PosibErr<unsigned int> ret = ths->retrieve_int(key); + ths->err_.reset(ret.release_err()); +diff -rubw aspell-0.50.4.1/lib/document_checker-c.cpp aspell-win32/lib/document_checker-c.cpp +--- aspell-0.50.4.1/lib/document_checker-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/document_checker-c.cpp 2004-01-06 15:30:35.000000000 -0500 +@@ -6,6 +6,9 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "document_checker.hpp" + #include "error.hpp" + +@@ -17,27 +20,27 @@ + class Filter; + class Speller; + +-extern "C" void delete_aspell_document_checker(DocumentChecker * ths) ++extern "C" ASPELL_API void delete_aspell_document_checker(DocumentChecker * ths) + { + delete ths; + } + +-extern "C" unsigned int aspell_document_checker_error_number(const DocumentChecker * ths) ++extern "C" ASPELL_API unsigned int aspell_document_checker_error_number(const DocumentChecker * ths) + { + return ths->err_ == 0 ? 0 : 1; + } + +-extern "C" const char * aspell_document_checker_error_message(const DocumentChecker * ths) ++extern "C" ASPELL_API const char * aspell_document_checker_error_message(const DocumentChecker * ths) + { + return ths->err_ ? ths->err_->mesg : ""; + } + +-extern "C" const Error * aspell_document_checker_error(const DocumentChecker * ths) ++extern "C" ASPELL_API const Error * aspell_document_checker_error(const DocumentChecker * ths) + { + return ths->err_; + } + +-extern "C" CanHaveError * new_aspell_document_checker(Speller * speller) ++extern "C" ASPELL_API CanHaveError * new_aspell_document_checker(Speller * speller) + { + PosibErr<DocumentChecker *> ret = new_document_checker(speller); + if (ret.has_err()) { +@@ -47,27 +50,27 @@ + } + } + +-extern "C" DocumentChecker * to_aspell_document_checker(CanHaveError * obj) ++extern "C" ASPELL_API DocumentChecker * to_aspell_document_checker(CanHaveError * obj) + { + return static_cast<DocumentChecker *>(obj); + } + +-extern "C" void aspell_document_checker_reset(DocumentChecker * ths) ++extern "C" ASPELL_API void aspell_document_checker_reset(DocumentChecker * ths) + { + ths->reset(); + } + +-extern "C" void aspell_document_checker_process(DocumentChecker * ths, const char * str, int size) ++extern "C" ASPELL_API void aspell_document_checker_process(DocumentChecker * ths, const char * str, int size) + { + ths->process(str, size); + } + +-extern "C" Token aspell_document_checker_next_misspelling(DocumentChecker * ths) ++extern "C" ASPELL_API Token aspell_document_checker_next_misspelling(DocumentChecker * ths) + { + return ths->next_misspelling(); + } + +-extern "C" Filter * aspell_document_checker_filter(DocumentChecker * ths) ++extern "C" ASPELL_API Filter * aspell_document_checker_filter(DocumentChecker * ths) + { + return ths->filter(); + } +diff -rubw aspell-0.50.4.1/lib/error-c.cpp aspell-win32/lib/error-c.cpp +--- aspell-0.50.4.1/lib/error-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/error-c.cpp 2004-01-06 15:30:37.000000000 -0500 +@@ -7,6 +7,9 @@ + * at http://www.gnu.org/. */ + + #include "error.hpp" ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + + namespace acommon { + +diff -rubw aspell-0.50.4.1/lib/filter-c.cpp aspell-win32/lib/filter-c.cpp +--- aspell-0.50.4.1/lib/filter-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/filter-c.cpp 2004-01-06 15:30:39.000000000 -0500 +@@ -6,6 +6,9 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "error.hpp" + #include "filter.hpp" + +@@ -15,27 +18,27 @@ + struct Error; + class Filter; + +-extern "C" void delete_aspell_filter(Filter * ths) ++extern "C" ASPELL_API void delete_aspell_filter(Filter * ths) + { + delete ths; + } + +-extern "C" unsigned int aspell_filter_error_number(const Filter * ths) ++extern "C" ASPELL_API unsigned int aspell_filter_error_number(const Filter * ths) + { + return ths->err_ == 0 ? 0 : 1; + } + +-extern "C" const char * aspell_filter_error_message(const Filter * ths) ++extern "C" ASPELL_API const char * aspell_filter_error_message(const Filter * ths) + { + return ths->err_ ? ths->err_->mesg : ""; + } + +-extern "C" const Error * aspell_filter_error(const Filter * ths) ++extern "C" ASPELL_API const Error * aspell_filter_error(const Filter * ths) + { + return ths->err_; + } + +-extern "C" Filter * to_aspell_filter(CanHaveError * obj) ++extern "C" ASPELL_API Filter * to_aspell_filter(CanHaveError * obj) + { + return static_cast<Filter *>(obj); + } +diff -rubw aspell-0.50.4.1/lib/find_speller.cpp aspell-win32/lib/find_speller.cpp +--- aspell-0.50.4.1/lib/find_speller.cpp 2002-08-18 08:52:02.000000000 -0400 ++++ aspell-win32/lib/find_speller.cpp 2004-01-06 15:30:41.000000000 -0500 +@@ -9,7 +9,10 @@ + + // POSIX includes + #include <sys/types.h> ++#ifdef WIN32PORT ++#else + #include <dirent.h> ++#endif + + #include "asc_ctype.hpp" + #include "can_have_error.hpp" +diff -rubw aspell-0.50.4.1/lib/info-c.cpp aspell-win32/lib/info-c.cpp +--- aspell-0.50.4.1/lib/info-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/info-c.cpp 2004-01-06 15:30:43.000000000 -0500 +@@ -6,6 +6,9 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "info.hpp" + + namespace acommon { +@@ -18,92 +21,92 @@ + class ModuleInfoEnumeration; + class ModuleInfoList; + +-extern "C" ModuleInfoList * get_aspell_module_info_list(Config * config) ++extern "C" ASPELL_API ModuleInfoList * get_aspell_module_info_list(Config * config) + { + return get_module_info_list(config); + } + +-extern "C" int aspell_module_info_list_empty(const ModuleInfoList * ths) ++extern "C" ASPELL_API int aspell_module_info_list_empty(const ModuleInfoList * ths) + { + return ths->empty(); + } + +-extern "C" unsigned int aspell_module_info_list_size(const ModuleInfoList * ths) ++extern "C" ASPELL_API unsigned int aspell_module_info_list_size(const ModuleInfoList * ths) + { + return ths->size(); + } + +-extern "C" ModuleInfoEnumeration * aspell_module_info_list_elements(const ModuleInfoList * ths) ++extern "C" ASPELL_API ModuleInfoEnumeration * aspell_module_info_list_elements(const ModuleInfoList * ths) + { + return ths->elements(); + } + +-extern "C" DictInfoList * get_aspell_dict_info_list(Config * config) ++extern "C" ASPELL_API DictInfoList * get_aspell_dict_info_list(Config * config) + { + return get_dict_info_list(config); + } + +-extern "C" int aspell_dict_info_list_empty(const DictInfoList * ths) ++extern "C" ASPELL_API int aspell_dict_info_list_empty(const DictInfoList * ths) + { + return ths->empty(); + } + +-extern "C" unsigned int aspell_dict_info_list_size(const DictInfoList * ths) ++extern "C" ASPELL_API unsigned int aspell_dict_info_list_size(const DictInfoList * ths) + { + return ths->size(); + } + +-extern "C" DictInfoEnumeration * aspell_dict_info_list_elements(const DictInfoList * ths) ++extern "C" ASPELL_API DictInfoEnumeration * aspell_dict_info_list_elements(const DictInfoList * ths) + { + return ths->elements(); + } + +-extern "C" int aspell_module_info_enumeration_at_end(const ModuleInfoEnumeration * ths) ++extern "C" ASPELL_API int aspell_module_info_enumeration_at_end(const ModuleInfoEnumeration * ths) + { + return ths->at_end(); + } + +-extern "C" const ModuleInfo * aspell_module_info_enumeration_next(ModuleInfoEnumeration * ths) ++extern "C" ASPELL_API const ModuleInfo * aspell_module_info_enumeration_next(ModuleInfoEnumeration * ths) + { + return ths->next(); + } + +-extern "C" void delete_aspell_module_info_enumeration(ModuleInfoEnumeration * ths) ++extern "C" ASPELL_API void delete_aspell_module_info_enumeration(ModuleInfoEnumeration * ths) + { + delete ths; + } + +-extern "C" ModuleInfoEnumeration * aspell_module_info_enumeration_clone(const ModuleInfoEnumeration * ths) ++extern "C" ASPELL_API ModuleInfoEnumeration * aspell_module_info_enumeration_clone(const ModuleInfoEnumeration * ths) + { + return ths->clone(); + } + +-extern "C" void aspell_module_info_enumeration_assign(ModuleInfoEnumeration * ths, const ModuleInfoEnumeration * other) ++extern "C" ASPELL_API void aspell_module_info_enumeration_assign(ModuleInfoEnumeration * ths, const ModuleInfoEnumeration * other) + { + ths->assign(other); + } + +-extern "C" int aspell_dict_info_enumeration_at_end(const DictInfoEnumeration * ths) ++extern "C" ASPELL_API int aspell_dict_info_enumeration_at_end(const DictInfoEnumeration * ths) + { + return ths->at_end(); + } + +-extern "C" const DictInfo * aspell_dict_info_enumeration_next(DictInfoEnumeration * ths) ++extern "C" ASPELL_API const DictInfo * aspell_dict_info_enumeration_next(DictInfoEnumeration * ths) + { + return ths->next(); + } + +-extern "C" void delete_aspell_dict_info_enumeration(DictInfoEnumeration * ths) ++extern "C" ASPELL_API void delete_aspell_dict_info_enumeration(DictInfoEnumeration * ths) + { + delete ths; + } + +-extern "C" DictInfoEnumeration * aspell_dict_info_enumeration_clone(const DictInfoEnumeration * ths) ++extern "C" ASPELL_API DictInfoEnumeration * aspell_dict_info_enumeration_clone(const DictInfoEnumeration * ths) + { + return ths->clone(); + } + +-extern "C" void aspell_dict_info_enumeration_assign(DictInfoEnumeration * ths, const DictInfoEnumeration * other) ++extern "C" ASPELL_API void aspell_dict_info_enumeration_assign(DictInfoEnumeration * ths, const DictInfoEnumeration * other) + { + ths->assign(other); + } +diff -rubw aspell-0.50.4.1/lib/mutable_container-c.cpp aspell-win32/lib/mutable_container-c.cpp +--- aspell-0.50.4.1/lib/mutable_container-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/mutable_container-c.cpp 2004-01-06 15:30:45.000000000 -0500 +@@ -6,6 +6,9 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "mutable_container.hpp" + #include "posib_err.hpp" + +@@ -13,22 +16,22 @@ + + class MutableContainer; + +-extern "C" int aspell_mutable_container_add(MutableContainer * ths, const char * to_add) ++extern "C" ASPELL_API int aspell_mutable_container_add(MutableContainer * ths, const char * to_add) + { + return ths->add(to_add); + } + +-extern "C" int aspell_mutable_container_remove(MutableContainer * ths, const char * to_rem) ++extern "C" ASPELL_API int aspell_mutable_container_remove(MutableContainer * ths, const char * to_rem) + { + return ths->remove(to_rem); + } + +-extern "C" void aspell_mutable_container_clear(MutableContainer * ths) ++extern "C" ASPELL_API void aspell_mutable_container_clear(MutableContainer * ths) + { + ths->clear(); + } + +-extern "C" MutableContainer * aspell_mutable_container_to_mutable_container(MutableContainer * ths) ++extern "C" ASPELL_API MutableContainer * aspell_mutable_container_to_mutable_container(MutableContainer * ths) + { + return ths; + } +diff -rubw aspell-0.50.4.1/lib/new_config.cpp aspell-win32/lib/new_config.cpp +--- aspell-0.50.4.1/lib/new_config.cpp 2002-07-26 22:27:10.000000000 -0400 ++++ aspell-win32/lib/new_config.cpp 2004-01-06 15:30:47.000000000 -0500 +@@ -38,7 +38,11 @@ + Config * config; + ModeNotifierImpl(Config * c) : config(c) {} + ++#ifdef WIN32PORT ++ Notifier * clone(Config * c) const {return new ModeNotifierImpl(c);} //FB ++#else + ModeNotifierImpl * clone(Config * c) const {return new ModeNotifierImpl(c);} ++#endif + PosibErr<void> item_updated(const KeyInfo * ki, ParmString value) { + if (strcmp(ki->name, "mode") == 0) { + +diff -rubw aspell-0.50.4.1/lib/speller-c.cpp aspell-win32/lib/speller-c.cpp +--- aspell-0.50.4.1/lib/speller-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/speller-c.cpp 2004-01-16 08:50:33.000000000 -0500 +@@ -6,6 +6,9 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "convert.hpp" + #include "error.hpp" + #include "mutable_string.hpp" +@@ -21,7 +24,7 @@ + class Speller; + class WordList; + +-extern "C" CanHaveError * new_aspell_speller(Config * config) ++extern "C" ASPELL_API CanHaveError * new_aspell_speller(Config * config) + { + PosibErr<Speller *> ret = new_speller(config); + if (ret.has_err()) { +@@ -31,37 +34,37 @@ + } + } + +-extern "C" Speller * to_aspell_speller(CanHaveError * obj) ++extern "C" ASPELL_API Speller * to_aspell_speller(CanHaveError * obj) + { + return static_cast<Speller *>(obj); + } + +-extern "C" void delete_aspell_speller(Speller * ths) ++extern "C" ASPELL_API void delete_aspell_speller(Speller * ths) + { + delete ths; + } + +-extern "C" unsigned int aspell_speller_error_number(const Speller * ths) ++extern "C" ASPELL_API unsigned int aspell_speller_error_number(const Speller * ths) + { + return ths->err_ == 0 ? 0 : 1; + } + +-extern "C" const char * aspell_speller_error_message(const Speller * ths) ++extern "C" ASPELL_API const char * aspell_speller_error_message(const Speller * ths) + { + return ths->err_ ? ths->err_->mesg : ""; + } + +-extern "C" const Error * aspell_speller_error(const Speller * ths) ++extern "C" ASPELL_API const Error * aspell_speller_error(const Speller * ths) + { + return ths->err_; + } + +-extern "C" Config * aspell_speller_config(Speller * ths) ++extern "C" ASPELL_API Config * aspell_speller_config(Speller * ths) + { + return ths->config(); + } + +-extern "C" int aspell_speller_check(Speller * ths, const char * word, int word_size) ++extern "C" ASPELL_API int aspell_speller_check(Speller * ths, const char * word, int word_size) + { + ths->temp_str_0.clear(); + ths->to_internal_->convert(word, word_size, ths->temp_str_0); +@@ -74,7 +77,7 @@ + return ret.data; + } + +-extern "C" int aspell_speller_add_to_personal(Speller * ths, const char * word, int word_size) ++extern "C" ASPELL_API int aspell_speller_add_to_personal(Speller * ths, const char * word, int word_size) + { + ths->temp_str_0.clear(); + ths->to_internal_->convert(word, word_size, ths->temp_str_0); +@@ -87,7 +90,7 @@ + return 1; + } + +-extern "C" int aspell_speller_add_to_session(Speller * ths, const char * word, int word_size) ++extern "C" ASPELL_API int aspell_speller_add_to_session(Speller * ths, const char * word, int word_size) + { + ths->temp_str_0.clear(); + ths->to_internal_->convert(word, word_size, ths->temp_str_0); +@@ -100,7 +103,7 @@ + return 1; + } + +-extern "C" const WordList * aspell_speller_personal_word_list(Speller * ths) ++extern "C" ASPELL_API const WordList * aspell_speller_personal_word_list(Speller * ths) + { + PosibErr<const WordList *> ret = ths->personal_word_list(); + ths->err_.reset(ret.release_err()); +@@ -109,7 +112,7 @@ + return ret.data; + } + +-extern "C" const WordList * aspell_speller_session_word_list(Speller * ths) ++extern "C" ASPELL_API const WordList * aspell_speller_session_word_list(Speller * ths) + { + PosibErr<const WordList *> ret = ths->session_word_list(); + ths->err_.reset(ret.release_err()); +@@ -118,7 +121,7 @@ + return ret.data; + } + +-extern "C" const WordList * aspell_speller_main_word_list(Speller * ths) ++extern "C" ASPELL_API const WordList * aspell_speller_main_word_list(Speller * ths) + { + PosibErr<const WordList *> ret = ths->main_word_list(); + ths->err_.reset(ret.release_err()); +@@ -127,7 +130,7 @@ + return ret.data; + } + +-extern "C" int aspell_speller_save_all_word_lists(Speller * ths) ++extern "C" ASPELL_API int aspell_speller_save_all_word_lists(Speller * ths) + { + PosibErr<void> ret = ths->save_all_word_lists(); + ths->err_.reset(ret.release_err()); +@@ -135,7 +138,7 @@ + return 1; + } + +-extern "C" int aspell_speller_clear_session(Speller * ths) ++extern "C" ASPELL_API int aspell_speller_clear_session(Speller * ths) + { + PosibErr<void> ret = ths->clear_session(); + ths->err_.reset(ret.release_err()); +@@ -143,7 +146,7 @@ + return 1; + } + +-extern "C" const WordList * aspell_speller_suggest(Speller * ths, const char * word, int word_size) ++extern "C" ASPELL_API const WordList * aspell_speller_suggest(Speller * ths, const char * word, int word_size) + { + ths->temp_str_0.clear(); + ths->to_internal_->convert(word, word_size, ths->temp_str_0); +@@ -157,7 +160,7 @@ + return ret.data; + } + +-extern "C" int aspell_speller_store_replacement(Speller * ths, const char * mis, int mis_size, const char * cor, int cor_size) ++extern "C" ASPELL_API int aspell_speller_store_replacement(Speller * ths, const char * mis, int mis_size, const char * cor, int cor_size) + { + ths->temp_str_0.clear(); + ths->to_internal_->convert(mis, mis_size, ths->temp_str_0); +diff -rubw aspell-0.50.4.1/lib/string_enumeration-c.cpp aspell-win32/lib/string_enumeration-c.cpp +--- aspell-0.50.4.1/lib/string_enumeration-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/string_enumeration-c.cpp 2004-01-06 15:30:50.000000000 -0500 +@@ -6,6 +6,9 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "convert.hpp" + #include "string_enumeration.hpp" + +@@ -13,27 +16,27 @@ + + class StringEnumeration; + +-extern "C" void delete_aspell_string_enumeration(StringEnumeration * ths) ++extern "C" ASPELL_API void delete_aspell_string_enumeration(StringEnumeration * ths) + { + delete ths; + } + +-extern "C" StringEnumeration * aspell_string_enumeration_clone(const StringEnumeration * ths) ++extern "C" ASPELL_API StringEnumeration * aspell_string_enumeration_clone(const StringEnumeration * ths) + { + return ths->clone(); + } + +-extern "C" void aspell_string_enumeration_assign(StringEnumeration * ths, const StringEnumeration * other) ++extern "C" ASPELL_API void aspell_string_enumeration_assign(StringEnumeration * ths, const StringEnumeration * other) + { + ths->assign(other); + } + +-extern "C" int aspell_string_enumeration_at_end(const StringEnumeration * ths) ++extern "C" ASPELL_API int aspell_string_enumeration_at_end(const StringEnumeration * ths) + { + return ths->at_end(); + } + +-extern "C" const char * aspell_string_enumeration_next(StringEnumeration * ths) ++extern "C" ASPELL_API const char * aspell_string_enumeration_next(StringEnumeration * ths) + { + const char * s = ths->next(); + if (s == 0 || ths->from_internal_ == 0) { +diff -rubw aspell-0.50.4.1/lib/string_list-c.cpp aspell-win32/lib/string_list-c.cpp +--- aspell-0.50.4.1/lib/string_list-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/string_list-c.cpp 2004-01-06 15:30:51.000000000 -0500 +@@ -6,6 +6,9 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "posib_err.hpp" + #include "string_list.hpp" + +@@ -15,57 +18,57 @@ + class StringEnumeration; + class StringList; + +-extern "C" StringList * new_aspell_string_list() ++extern "C" ASPELL_API StringList * new_aspell_string_list() + { + return new_string_list(); + } + +-extern "C" int aspell_string_list_empty(const StringList * ths) ++extern "C" ASPELL_API int aspell_string_list_empty(const StringList * ths) + { + return ths->empty(); + } + +-extern "C" unsigned int aspell_string_list_size(const StringList * ths) ++extern "C" ASPELL_API unsigned int aspell_string_list_size(const StringList * ths) + { + return ths->size(); + } + +-extern "C" StringEnumeration * aspell_string_list_elements(const StringList * ths) ++extern "C" ASPELL_API StringEnumeration * aspell_string_list_elements(const StringList * ths) + { + return ths->elements(); + } + +-extern "C" int aspell_string_list_add(StringList * ths, const char * to_add) ++extern "C" ASPELL_API int aspell_string_list_add(StringList * ths, const char * to_add) + { + return ths->add(to_add); + } + +-extern "C" int aspell_string_list_remove(StringList * ths, const char * to_rem) ++extern "C" ASPELL_API int aspell_string_list_remove(StringList * ths, const char * to_rem) + { + return ths->remove(to_rem); + } + +-extern "C" void aspell_string_list_clear(StringList * ths) ++extern "C" ASPELL_API void aspell_string_list_clear(StringList * ths) + { + ths->clear(); + } + +-extern "C" MutableContainer * aspell_string_list_to_mutable_container(StringList * ths) ++extern "C" ASPELL_API MutableContainer * aspell_string_list_to_mutable_container(StringList * ths) + { + return ths; + } + +-extern "C" void delete_aspell_string_list(StringList * ths) ++extern "C" ASPELL_API void delete_aspell_string_list(StringList * ths) + { + delete ths; + } + +-extern "C" StringList * aspell_string_list_clone(const StringList * ths) ++extern "C" ASPELL_API StringList * aspell_string_list_clone(const StringList * ths) + { + return ths->clone(); + } + +-extern "C" void aspell_string_list_assign(StringList * ths, const StringList * other) ++extern "C" ASPELL_API void aspell_string_list_assign(StringList * ths, const StringList * other) + { + ths->assign(other); + } +diff -rubw aspell-0.50.4.1/lib/string_map-c.cpp aspell-win32/lib/string_map-c.cpp +--- aspell-0.50.4.1/lib/string_map-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/string_map-c.cpp 2004-01-06 15:30:53.000000000 -0500 +@@ -6,6 +6,9 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "posib_err.hpp" + #include "string_map.hpp" + +@@ -15,72 +18,72 @@ + class StringMap; + class StringPairEnumeration; + +-extern "C" StringMap * new_aspell_string_map() ++extern "C" ASPELL_API StringMap * new_aspell_string_map() + { + return new_string_map(); + } + +-extern "C" int aspell_string_map_add(StringMap * ths, const char * to_add) ++extern "C" ASPELL_API int aspell_string_map_add(StringMap * ths, const char * to_add) + { + return ths->add(to_add); + } + +-extern "C" int aspell_string_map_remove(StringMap * ths, const char * to_rem) ++extern "C" ASPELL_API int aspell_string_map_remove(StringMap * ths, const char * to_rem) + { + return ths->remove(to_rem); + } + +-extern "C" void aspell_string_map_clear(StringMap * ths) ++extern "C" ASPELL_API void aspell_string_map_clear(StringMap * ths) + { + ths->clear(); + } + +-extern "C" MutableContainer * aspell_string_map_to_mutable_container(StringMap * ths) ++extern "C" ASPELL_API MutableContainer * aspell_string_map_to_mutable_container(StringMap * ths) + { + return ths; + } + +-extern "C" void delete_aspell_string_map(StringMap * ths) ++extern "C" ASPELL_API void delete_aspell_string_map(StringMap * ths) + { + delete ths; + } + +-extern "C" StringMap * aspell_string_map_clone(const StringMap * ths) ++extern "C" ASPELL_API StringMap * aspell_string_map_clone(const StringMap * ths) + { + return ths->clone(); + } + +-extern "C" void aspell_string_map_assign(StringMap * ths, const StringMap * other) ++extern "C" ASPELL_API void aspell_string_map_assign(StringMap * ths, const StringMap * other) + { + ths->assign(other); + } + +-extern "C" int aspell_string_map_empty(const StringMap * ths) ++extern "C" ASPELL_API int aspell_string_map_empty(const StringMap * ths) + { + return ths->empty(); + } + +-extern "C" unsigned int aspell_string_map_size(const StringMap * ths) ++extern "C" ASPELL_API unsigned int aspell_string_map_size(const StringMap * ths) + { + return ths->size(); + } + +-extern "C" StringPairEnumeration * aspell_string_map_elements(const StringMap * ths) ++extern "C" ASPELL_API StringPairEnumeration * aspell_string_map_elements(const StringMap * ths) + { + return ths->elements(); + } + +-extern "C" int aspell_string_map_insert(StringMap * ths, const char * key, const char * value) ++extern "C" ASPELL_API int aspell_string_map_insert(StringMap * ths, const char * key, const char * value) + { + return ths->insert(key, value); + } + +-extern "C" int aspell_string_map_replace(StringMap * ths, const char * key, const char * value) ++extern "C" ASPELL_API int aspell_string_map_replace(StringMap * ths, const char * key, const char * value) + { + return ths->replace(key, value); + } + +-extern "C" const char * aspell_string_map_lookup(const StringMap * ths, const char * key) ++extern "C" ASPELL_API const char * aspell_string_map_lookup(const StringMap * ths, const char * key) + { + return ths->lookup(key); + } +diff -rubw aspell-0.50.4.1/lib/string_pair_enumeration-c.cpp aspell-win32/lib/string_pair_enumeration-c.cpp +--- aspell-0.50.4.1/lib/string_pair_enumeration-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/string_pair_enumeration-c.cpp 2004-01-06 15:30:55.000000000 -0500 +@@ -6,6 +6,9 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "string_pair.hpp" + #include "string_pair_enumeration.hpp" + +@@ -13,27 +16,34 @@ + + class StringPairEnumeration; + +-extern "C" int aspell_string_pair_enumeration_at_end(const StringPairEnumeration * ths) ++extern "C" ASPELL_API int aspell_string_pair_enumeration_at_end(const StringPairEnumeration * ths) + { + return ths->at_end(); + } + ++#ifdef WIN32PORT ++extern "C" ASPELL_API StringPair* aspell_string_pair_enumeration_next(StringPairEnumeration * ths) ++{ ++ return &ths->next(); ++} ++#else + extern "C" StringPair aspell_string_pair_enumeration_next(StringPairEnumeration * ths) + { + return ths->next(); + } ++#endif + +-extern "C" void delete_aspell_string_pair_enumeration(StringPairEnumeration * ths) ++extern "C" ASPELL_API void delete_aspell_string_pair_enumeration(StringPairEnumeration * ths) + { + delete ths; + } + +-extern "C" StringPairEnumeration * aspell_string_pair_enumeration_clone(const StringPairEnumeration * ths) ++extern "C" ASPELL_API StringPairEnumeration * aspell_string_pair_enumeration_clone(const StringPairEnumeration * ths) + { + return ths->clone(); + } + +-extern "C" void aspell_string_pair_enumeration_assign(StringPairEnumeration * ths, const StringPairEnumeration * other) ++extern "C" ASPELL_API void aspell_string_pair_enumeration_assign(StringPairEnumeration * ths, const StringPairEnumeration * other) + { + ths->assign(other); + } +diff -rubw aspell-0.50.4.1/lib/word_list-c.cpp aspell-win32/lib/word_list-c.cpp +--- aspell-0.50.4.1/lib/word_list-c.cpp 2002-08-30 15:20:36.000000000 -0400 ++++ aspell-win32/lib/word_list-c.cpp 2004-01-06 15:30:57.000000000 -0500 +@@ -6,6 +6,9 @@ + * LGPL license along with this library if you did not you can find it + * at http://www.gnu.org/. */ + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "string_enumeration.hpp" + #include "word_list.hpp" + +@@ -14,17 +17,17 @@ + class StringEnumeration; + class WordList; + +-extern "C" int aspell_word_list_empty(const WordList * ths) ++extern "C" ASPELL_API int aspell_word_list_empty(const WordList * ths) + { + return ths->empty(); + } + +-extern "C" unsigned int aspell_word_list_size(const WordList * ths) ++extern "C" ASPELL_API unsigned int aspell_word_list_size(const WordList * ths) + { + return ths->size(); + } + +-extern "C" StringEnumeration * aspell_word_list_elements(const WordList * ths) ++extern "C" ASPELL_API StringEnumeration * aspell_word_list_elements(const WordList * ths) + { + StringEnumeration * els = ths->elements(); + els->from_internal_ = ths->from_internal_; +diff -rubw aspell-0.50.4.1/manual/man-html/4_Customizing.html aspell-win32/manual/man-html/4_Customizing.html +--- aspell-0.50.4.1/manual/man-html/4_Customizing.html 2003-10-11 20:17:36.000000000 -0400 ++++ aspell-win32/manual/man-html/4_Customizing.html 2004-01-13 09:30:29.000000000 -0500 +@@ -444,7 +444,10 @@ + </DD> + <DT><STRONG>save-repl</STRONG></DT> + <DD><I>(boolean)</I> save the replacement word list on save +-allkeyboard <I>(file)</I> the base name of the keyboard definition ++all ++</DD> ++<DT><STRONG>keyboard</STRONG></DT> ++<DD><I>(file)</I> the base name of the keyboard definition + file to use (see section <A HREF="4_Customizing.html#typo">4.4.3</A>) + </DD> + <DT><STRONG>sug-mode</STRONG></DT> +diff -rubw aspell-0.50.4.1/modules/speller/default/block_vector.hpp aspell-win32/modules/speller/default/block_vector.hpp +--- aspell-0.50.4.1/modules/speller/default/block_vector.hpp 2001-11-29 22:55:48.000000000 -0500 ++++ aspell-win32/modules/speller/default/block_vector.hpp 2004-01-06 15:31:07.000000000 -0500 +@@ -30,7 +30,13 @@ + typedef T & reference; + typedef const T & const_reference; + typedef T * pointer; ++#ifdef WIN32PORT ++ typedef T * _Tptr; //FB ++#endif + typedef T * const_pointer; ++#ifdef WIN32PORT ++ typedef T * _Ctptr; //FB; ++#endif + typedef std::random_access_iterator_tag iterator_category; + typedef ptrdiff_t distance_type; + +diff -rubw aspell-0.50.4.1/modules/speller/default/data.cpp aspell-win32/modules/speller/default/data.cpp +--- aspell-0.50.4.1/modules/speller/default/data.cpp 2003-01-13 06:14:02.000000000 -0500 ++++ aspell-win32/modules/speller/default/data.cpp 2004-01-06 15:31:11.000000000 -0500 +@@ -73,7 +73,11 @@ + } + + bool DataSet::is_attached() const { ++#ifdef WIN32PORT ++ return attach_count_ == 0; //FB ++#else + return attach_count_; ++#endif + } + + const char * DataSet::lang_name() const { +diff -rubw aspell-0.50.4.1/modules/speller/default/data.hpp aspell-win32/modules/speller/default/data.hpp +--- aspell-0.50.4.1/modules/speller/default/data.hpp 2003-01-13 06:12:44.000000000 -0500 ++++ aspell-win32/modules/speller/default/data.hpp 2004-01-16 08:55:02.000000000 -0500 +@@ -5,6 +5,9 @@ + + #include <assert.h> + ++#ifdef WIN32PORT ++#include "aspellroot.h" ++#endif + #include "copy_ptr.hpp" + #include "enumeration.hpp" + #include "language.hpp" +@@ -26,7 +29,13 @@ + class SpellerImpl; + class Language; + ++#ifdef WIN32PORT ++#pragma warning( disable : 4099 ) ++#endif + class SensitiveCompare; ++#ifdef WIN32PORT ++#pragma warning( default : 4099 ) ++#endif + + class DataSet { + friend class SpellerImpl; +@@ -101,7 +110,7 @@ + virtual PosibErr<void> clear() = 0; + }; + +- struct CompoundInfo { ++ struct ASPELL_API CompoundInfo { + unsigned char d; + + CompoundInfo(unsigned char d0 = 0) : d(d0) {} +@@ -113,19 +122,39 @@ + d |= c; + } + ++#ifdef WIN32PORT ++ bool mid_required () const {return (d & 1<<2) != 0; } //FB ++#else + bool mid_required () const {return d & 1<<2; } ++#endif + void mid_required (bool c) { d |= c<<2;} + ++#ifdef WIN32PORT ++ bool beg () const {return (d & 1<<3) != 0;} //FB ++#else + bool beg () const {return d & 1<<3;} ++#endif + void beg (bool c) {d |= c<<3;} + ++#ifdef WIN32PORT ++ bool mid () const {return (d & 1<<4) != 0;} //FB ++#else + bool mid () const {return d & 1<<4;} ++#endif + void mid (bool c) {d |= c<<4;} + ++#ifdef WIN32PORT ++ bool end () const {return (d & 1<<5) != 0;} //FB ++#else + bool end () const {return d & 1<<5;} ++#endif + void end (bool c) {d |= c<<5;} + ++#ifdef WIN32PORT ++ bool any() const {return (d & (1<<3|1<<4|1<<5)) != 0;} //FB ++#else + bool any() const {return d & (1<<3|1<<4|1<<5);} ++#endif + + const char * read(const char * str, const Language & l); + OStream & write(OStream &, const Language & l) const; +@@ -143,7 +172,11 @@ + const char * soundslike; + const void * word_list_pointer; + ++#ifdef WIN32PORT ++ operator bool () const {return soundslike != 0;} //FB ++#else + operator bool () const {return soundslike;} ++#endif + + SoundslikeWord() : soundslike(0) {} + SoundslikeWord(const char * w, const void * p) +@@ -152,7 +185,7 @@ + + static const unsigned int MaxCompoundLength = 8; + +- struct BasicWordInfo { ++ struct ASPELL_API BasicWordInfo { + const char * word; + CompoundInfo compound; + BasicWordInfo(const char * w = 0, CompoundInfo c = 0) +@@ -189,7 +222,7 @@ + const ConvertWord &) const; + }; + +- struct LocalWordSetInfo ++ struct ASPELL_API LocalWordSetInfo + { + SensitiveCompare compare; + ConvertWord convert; +@@ -328,7 +361,7 @@ + static const DataType DT_Multi = 1<<3; + static const DataType DT_Any = 0xFF; + +- PosibErr<LoadableDataSet *> add_data_set(ParmString file_name, ++ PosibErr<LoadableDataSet *> ASPELL_API add_data_set(ParmString file_name, + Config &, + SpellerImpl * = 0, + const LocalWordSetInfo * = 0, +@@ -336,18 +369,18 @@ + DataType allowed = DT_Any); + + // implemented in readonly_ws.cc +- BasicWordSet * new_default_readonly_word_set(); +- PosibErr<void> create_default_readonly_word_set(StringEnumeration * els, ++ ASPELL_API BasicWordSet * new_default_readonly_word_set(); ++ ASPELL_API PosibErr<void> create_default_readonly_word_set(StringEnumeration * els, + Config & config); + + // implemented in multi_ws.cc +- BasicMultiSet * new_default_multi_word_set(); ++ ASPELL_API BasicMultiSet * new_default_multi_word_set(); + + // implemented in writable_ws.cc +- WritableWordSet * new_default_writable_word_set(); ++ ASPELL_API WritableWordSet * new_default_writable_word_set(); + + // implemented in writable_repl.cc +- WritableReplacementSet * new_default_writable_replacement_set(); ++ ASPELL_API WritableReplacementSet * new_default_writable_replacement_set(); + + + } +diff -rubw aspell-0.50.4.1/modules/speller/default/language.cpp aspell-win32/modules/speller/default/language.cpp +--- aspell-0.50.4.1/modules/speller/default/language.cpp 2002-07-24 04:02:52.000000000 -0400 ++++ aspell-win32/modules/speller/default/language.cpp 2004-01-06 15:31:22.000000000 -0500 +@@ -107,6 +107,21 @@ + String temp; + char_data.getline(temp); + char_data.getline(temp); ++#ifdef WIN32PORT ++ for (int j = 0; j != 256; ++j) { //FB ++ char_data >> to_uni_[j]; //FB ++ char_data >> temp; ++ char_type_[j] = temp == "letter" ? letter //FB ++ : temp == "space" ? space ++ : other; ++ int num = -1; ++ char_data >> num; to_lower_[j] = static_cast<char>(num); //FB ++ char_data >> num; to_upper_[j] = static_cast<char>(num); //FB ++ char_data >> num; to_title_[j] = static_cast<char>(num); //FB ++ char_data >> num; to_sl_[j] = static_cast<char>(num); //FB ++ char_data >> num; to_stripped_[j] = static_cast<char>(num); //FB ++ char_data >> num; de_accent_[j] = static_cast<char>(num); //FB ++#else + for (int i = 0; i != 256; ++i) { + char_data >> to_uni_[i]; + char_data >> temp; +@@ -120,6 +135,7 @@ + char_data >> num; to_sl_[i] = static_cast<char>(num); + char_data >> num; to_stripped_[i] = static_cast<char>(num); + char_data >> num; de_accent_[i] = static_cast<char>(num); ++#endif + if (char_data.peek() != '\n') + return make_err(bad_file_format, char_data_name); + } +@@ -128,10 +144,31 @@ + // + // + ++#ifdef WIN32PORT ++ for (j = 0; j != 256; ++j) //FB ++ to_normalized_[j] = 0; //FB ++#else + for (int i = 0; i != 256; ++i) + to_normalized_[i] = 0; ++#endif + + int c = 1; ++#ifdef WIN32PORT ++ for (j = 0; j != 256; ++j) {//FB ++ if (is_alpha(j)) { //FB ++ if (to_normalized_[to_uchar(to_stripped_[j])] == 0) { //FB ++ to_normalized_[j] = c; //FB ++ to_normalized_[to_uchar(to_stripped_[j])] = c; //FB ++ ++c; ++ } else { ++ to_normalized_[j] = to_normalized_[to_uchar(to_stripped_[j])]; //FB ++ } ++ } ++ } ++ for (j = 0; j != 256; ++j) { //FB ++ if (to_normalized_[j]==0) to_normalized_[j] = c; //FB ++ } ++#else + for (int i = 0; i != 256; ++i) { + if (is_alpha(i)) { + if (to_normalized_[to_uchar(to_stripped_[i])] == 0) { +@@ -146,6 +183,7 @@ + for (int i = 0; i != 256; ++i) { + if (to_normalized_[i]==0) to_normalized_[i] = c; + } ++#endif + max_normalized_ = c; + + // +diff -rubw aspell-0.50.4.1/modules/speller/default/language.hpp aspell-win32/modules/speller/default/language.hpp +--- aspell-0.50.4.1/modules/speller/default/language.hpp 2001-11-29 22:55:48.000000000 -0500 ++++ aspell-win32/modules/speller/default/language.hpp 2004-01-02 13:18:20.000000000 -0500 +@@ -57,7 +57,7 @@ + + public: + Language() {} +- PosibErr<void> setup(ParmString lang, Config *); ++ ASPELL_API PosibErr<void> setup(ParmString lang, Config *); + + const char * data_dir() const {return dir_.c_str();} + const char * name() const {return name_.c_str();} +@@ -155,7 +155,7 @@ + } + }; + +- struct SensitiveCompare { ++ struct ASPELL_API SensitiveCompare { + const Language * lang; + bool case_insensitive; + bool ignore_accents; +@@ -182,7 +182,7 @@ + // otherwise the casing of tail begin and tail inlist must match + }; + +- struct ConvertWord { ++ struct ASPELL_API ConvertWord { + const Language * lang; + bool strip_accents; + ConvertWord(const Language * l = 0) +diff -rubw aspell-0.50.4.1/modules/speller/default/multi_ws.cpp aspell-win32/modules/speller/default/multi_ws.cpp +--- aspell-0.50.4.1/modules/speller/default/multi_ws.cpp 2003-05-12 00:30:14.000000000 -0400 ++++ aspell-win32/modules/speller/default/multi_ws.cpp 2004-01-06 15:31:26.000000000 -0500 +@@ -87,7 +87,11 @@ + + MultiWS::VirEmul * MultiWS::detailed_elements() const + { ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<ElementsParms, VirEnumeration<ElementsParms::Value> >(wss.begin(), wss.end());//FB ++#else + return new MakeVirEnumeration<ElementsParms>(wss.begin(), wss.end()); ++#endif + } + + unsigned int MultiWS::size() const +diff -rubw aspell-0.50.4.1/modules/speller/default/phonet.cpp aspell-win32/modules/speller/default/phonet.cpp +--- aspell-0.50.4.1/modules/speller/default/phonet.cpp 2002-08-11 09:58:30.000000000 -0400 ++++ aspell-win32/modules/speller/default/phonet.cpp 2004-01-06 15:31:28.000000000 -0500 +@@ -70,7 +70,11 @@ + *this = *(const PhonetParmsImpl *)other; + this->rules = &rdata.front(); + } ++#ifdef WIN32PORT ++ PhonetParms * clone() const { //FB ??? (worried) ++#else + PhonetParmsImpl * clone() const { ++#endif + PhonetParmsImpl * other = new PhonetParmsImpl(*this); + return other; + } +@@ -191,7 +195,11 @@ + + int i, k; + ++#ifdef WIN32PORT ++ for (i = 0; i < parms.get_hash_size(); i++) { ++#else + for (i = 0; i < parms.hash_size; i++) { ++#endif + parms.hash[i] = -1; + } + +diff -rubw aspell-0.50.4.1/modules/speller/default/phonet.hpp aspell-win32/modules/speller/default/phonet.hpp +--- aspell-0.50.4.1/modules/speller/default/phonet.hpp 2001-11-29 22:55:48.000000000 -0500 ++++ aspell-win32/modules/speller/default/phonet.hpp 2004-01-06 15:31:31.000000000 -0500 +@@ -39,8 +39,13 @@ + char to_upper[256]; + bool is_alpha[256]; + ++#ifdef WIN32PORT ++ int get_hash_size(){ return 256;} //FB ++ int hash[256]; //FB ++#else + static const int hash_size = 256; + int hash[hash_size]; ++#endif + + virtual PhonetParms * clone() const = 0; + virtual void assign(const PhonetParms *) = 0; +diff -rubw aspell-0.50.4.1/modules/speller/default/phonetic.cpp aspell-win32/modules/speller/default/phonetic.cpp +--- aspell-0.50.4.1/modules/speller/default/phonetic.cpp 2001-11-29 22:55:48.000000000 -0500 ++++ aspell-win32/modules/speller/default/phonetic.cpp 2004-01-06 15:31:37.000000000 -0500 +@@ -7,6 +7,9 @@ + #include "file_util.hpp" + #include "file_data_util.hpp" + #include "clone_ptr-t.hpp" ++#ifdef WIN32PORT ++#include "generic_copy_ptr-t.hpp" ++#endif + + #include <vector> + +@@ -33,7 +36,11 @@ + char c = lang->to_sl(static_cast<char>(i)); + if (c) chars_set[static_cast<unsigned char>(c)] = true; + } ++#ifdef WIN32PORT ++ for (/*int*/ i = 0; i != 256; ++i) //FB ++#else + for (int i = 0; i != 256; ++i) ++#endif + { + if (chars_set[i]) + chars_list += static_cast<char>(i); +@@ -86,7 +93,11 @@ + if (lang->is_alpha(c) || lang->special(c).any()) + chars_set[static_cast<unsigned char>(lang->to_stripped(c))] = true; + } ++#ifdef WIN32PORT ++ for (/*int*/ i = 0; i != 256; ++i) //FB ++#else + for (int i = 0; i != 256; ++i) ++#endif + { + if (chars_set[i]) + chars_list += static_cast<char>(i); +@@ -158,11 +169,19 @@ + chars_set[static_cast<unsigned char>(*j)] = true; + } + } ++#ifdef WIN32PORT ++ for (int k = 0; k != 256; ++k) //FB ++ { ++ if (chars_set[k]) //FB ++ chars_list += static_cast<char>(k); //FB ++ } ++#else + for (int i = 0; i != 256; ++i) + { + if (chars_set[i]) + chars_list += static_cast<char>(i); + } ++#endif + return chars_list; + } + +@@ -207,6 +226,9 @@ + + } + ++#ifdef WIN32PORT ++#else + namespace acommon { + template class ClonePtr<aspeller::Soundslike>; + } ++#endif +diff -rubw aspell-0.50.4.1/modules/speller/default/readonly_ws.cpp aspell-win32/modules/speller/default/readonly_ws.cpp +--- aspell-0.50.4.1/modules/speller/default/readonly_ws.cpp 2002-11-25 19:21:52.000000000 -0500 ++++ aspell-win32/modules/speller/default/readonly_ws.cpp 2004-01-06 15:31:48.000000000 -0500 +@@ -66,6 +66,9 @@ + // And like the .wrd file the hash table contains offsets not pointers. + // + ++#ifdef WIN32PORT ++# pragma warning(disable:4786) ++#endif + #include <vector> + + using std::vector; +@@ -175,7 +178,10 @@ + typedef BlockVector<const u32int> Vector; + typedef u32int Value; + typedef const char * Key; ++#ifdef WIN32PORT ++#else + static const bool is_multi = true; ++#endif + Key key(Value v) const {assert (v != u32int_max); + return block_begin + v;} + InsensitiveHash hash; +@@ -192,7 +198,10 @@ + typedef BlockVector<const u32int> Vector; + typedef u32int Value; + typedef const char * Key; ++#ifdef WIN32PORT ++#else + static const bool is_multi = false; ++#endif + Key key(Value v) const {return block_begin + v;} + hash<const char *> hash; + bool equal(Key rhs, Key lhs) const {return strcmp(rhs,lhs) == 0;} +@@ -267,7 +276,11 @@ + }; + + ReadOnlyWS::VirEmul * ReadOnlyWS::detailed_elements() const { ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<ElementsParms, VirEnumeration<ElementsParms::Value> > ++#else + return new MakeVirEnumeration<ElementsParms> ++#endif + (word_lookup.begin(), ElementsParms(block)); + } + +@@ -512,12 +525,22 @@ + + if (use_soundslike) { + ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<SoundslikeElementsParms, //FB ++ VirEnumeration<SoundslikeElementsParms::Value> > //FB ++#else + return new MakeVirEnumeration<SoundslikeElementsParms> ++#endif + (soundslike_lookup.begin(), soundslike_block); + + } else { + ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<SoundslikeElementsParmsNoSL, //FB ++ VirEnumeration<SoundslikeElementsParmsNoSL::Value> > //FB ++#else + return new MakeVirEnumeration<SoundslikeElementsParmsNoSL> ++#endif + (word_lookup.begin(), + SoundslikeElementsParmsNoSL(max_word_length,block,lang())); + +@@ -540,7 +563,12 @@ + } else { + + WordLookup::ConstFindIterator i = word_lookup.multi_find(soundslike); ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<SoundslikeWordsParmsNoSL, ++ VirEnumeration<SoundslikeWordsParmsNoSL::Value> >(i, block); ++#else + return new MakeVirEnumeration<SoundslikeWordsParmsNoSL>(i, block); ++#endif + + } + +@@ -554,7 +582,12 @@ + const u32int * end = reinterpret_cast<const u32int *>(w.soundslike - 2); + u16int size = *reinterpret_cast<const u16int *>(end); + ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<SoundslikeWordsParms, ++ VirEnumeration<SoundslikeWordsParms::Value> > ++#else + return new MakeVirEnumeration<SoundslikeWordsParms> ++#endif + (end - size, SoundslikeWordsParms(word_block, end)); + + } else { +@@ -584,7 +617,11 @@ + typedef vector<const char *> Vector; + typedef const char * Value; + typedef const char * Key; ++#ifdef WIN32PORT ++ static const bool is_multi;//FB = true; ++#else + static const bool is_multi = true; ++#endif + const Key & key(const Value & v) const {return v;} + InsensitiveHash hash_; + size_t hash(const Key & k) const {return hash_(k);} +@@ -595,6 +632,9 @@ + bool is_nonexistent(const Value & v) const {return v == 0;} + void make_nonexistent(Value & v) const {v = 0;} + }; ++#ifdef WIN32PORT ++ const bool WordLookupParms::is_multi = true; ++#endif + + typedef VectorHashTable<WordLookupParms> WordHash; + +@@ -610,7 +650,11 @@ + }; + typedef pair<Key, List> Value; + typedef vector<Value> Vector; ++#ifdef WIN32PORT ++ static const bool is_multi;//FB = false; ++#else + static const bool is_multi = false; ++#endif + const Key & key(const Value & v) const {return v.first;} + hash<const char *> hash; + bool equal(const Key & rhs, const Key & lhs) const {return strcmp(rhs,lhs) == 0;} +@@ -620,6 +664,9 @@ + } + }; + ++#ifdef WIN32PORT ++ const bool SoundslikeLookupParms::is_multi = false; ++#endif + typedef VectorHashTable<SoundslikeLookupParms> SoundHash; + + static inline unsigned int round_up(unsigned int i, unsigned int size) { +diff -rubw aspell-0.50.4.1/modules/speller/default/simple_string.hpp aspell-win32/modules/speller/default/simple_string.hpp +--- aspell-0.50.4.1/modules/speller/default/simple_string.hpp 2001-11-29 22:55:48.000000000 -0500 ++++ aspell-win32/modules/speller/default/simple_string.hpp 2004-01-06 15:31:59.000000000 -0500 +@@ -33,7 +33,11 @@ + + SimpleString(const char * other, int) + : str_(other), delete_(false) {} ++#ifdef WIN32PORT ++ ~SimpleString() {if (delete_) delete[] const_cast<char*>(str_);} //FB ++#else + ~SimpleString() {if (delete_) delete[] str_;} ++#endif + const char * c_str() const {return str_;} + }; + +diff -rubw aspell-0.50.4.1/modules/speller/default/speller_impl.cpp aspell-win32/modules/speller/default/speller_impl.cpp +--- aspell-0.50.4.1/modules/speller/default/speller_impl.cpp 2002-09-23 22:30:28.000000000 -0400 ++++ aspell-win32/modules/speller/default/speller_impl.cpp 2004-01-16 08:50:32.000000000 -0500 +@@ -240,7 +240,11 @@ + words[0].set(s.word, *i == m ? m : '\0'); + words[1].clear(); + if ((!check_if_valid || !c.mid_required()) // if check then !s.mid_required() ++#ifdef WIN32PORT ++ && (bool) check(i, word_end, run_together_limit - 1, end_pos, words + 1)) //FB ++#else + && check(i, word_end, run_together_limit - 1, end_pos, words + 1)) ++#endif + return true; + if ((check_if_valid ? *i == m : strchr(run_together_middle_, *i) != 0) + && word_end - (i + 1) >= static_cast<int>(run_together_min_)) { +@@ -277,8 +281,12 @@ + } + + SpellerImpl::WordLists SpellerImpl::wordlists() const { +- return WordLists(MakeVirEnumeration<DataSetCollection::Parms> ++#ifdef WIN32PORT ++ return WordLists(MakeVirEnumeration<DataSetCollection::Parms, VirEnumeration<DataSetCollection::Parms::Value> > //FB + (wls_->begin(), DataSetCollection::Parms(wls_->end()))); ++#else ++ return WordLists(MakeVirEnumeration<DataSetCollection::Parms> ++#endif + } + + bool SpellerImpl::have(const DataSet::Id &to_find) const { +@@ -520,6 +528,8 @@ + + }; + ++#ifdef WIN32PORT ++#else + static UpdateMember update_members[] = + { + {"ignore", UpdateMember::Int, UpdateMember::CN::ignore} +@@ -538,11 +548,43 @@ + UpdateMember::Int, + UpdateMember::CN::run_together_min} + }; ++#endif + + template <typename T> + PosibErr<void> callback(SpellerImpl * m, const KeyInfo * ki, T value, + UpdateMember::Type t) + { ++#ifdef WIN32PORT ++ //FB (well, VC++ gets totally confused by fun) ++ static UpdateMember update_members[9]; ++ update_members[0].name = "ignore"; ++ update_members[0].type = UpdateMember::Int; ++ update_members[0].fun = UpdateMember::CN::ignore; ++ update_members[1].name = "ignore_accents"; ++ update_members[1].type = UpdateMember::Bool; ++ update_members[1].fun = UpdateMember::CN::ignore_accents; ++ update_members[2].name = "ignore_case"; ++ update_members[2].type = UpdateMember::Bool; ++ update_members[2].fun = UpdateMember::CN::ignore_case; ++ update_members[3].name = "ignore_repl"; ++ update_members[3].type = UpdateMember::Bool; ++ update_members[3].fun = UpdateMember::CN::ignore_repl; ++ update_members[4].name = "save_repl"; ++ update_members[4].type = UpdateMember::Bool; ++ update_members[4].fun = UpdateMember::CN::save_repl; ++ update_members[5].name = "sug-mode"; ++ update_members[5].type = UpdateMember::String; ++ update_members[5].fun = UpdateMember::CN::sug_mode; ++ update_members[6].name = "run-together-min"; ++ update_members[6].type = UpdateMember::Bool; ++ update_members[6].fun = UpdateMember::CN::run_together; ++ update_members[7].name = "run-together-limit"; ++ update_members[7].type = UpdateMember::Int; ++ update_members[7].fun = UpdateMember::CN::run_together_limit; ++ update_members[8].name = "run-together-min"; ++ update_members[8].type = UpdateMember::Int; ++ update_members[8].fun = UpdateMember::CN::run_together_min; ++#endif + const UpdateMember * i + = update_members; + const UpdateMember * end +@@ -573,7 +615,11 @@ + config_.reset(c); + + ignore_repl = config_->retrieve_bool("ignore-repl"); ++#ifdef WIN32PORT ++ ignore_count = (unsigned int)config_->retrieve_int("ignore"); ++#else + ignore_count = config_->retrieve_int("ignore"); ++#endif + + wls_.reset(new DataSetCollection()); + +@@ -638,14 +684,26 @@ + run_together_specified_ = config_->retrieve_bool("run-together-specified"); + run_together_middle_ = lang().mid_chars(); + ++#ifdef WIN32PORT ++ run_together_limit_ = (unsigned int)config_->retrieve_int("run-together-limit"); //FB ++#else + run_together_limit_ = config_->retrieve_int("run-together-limit"); ++#endif + if (run_together_limit_ > 8) { + config_->replace("run-together-limit", "8"); + run_together_limit_ = 8; + } ++#ifdef WIN32PORT ++ run_together_min_ = (unsigned int)config_->retrieve_int("run-together-min"); //FB ++#else + run_together_min_ = config_->retrieve_int("run-together-min"); ++#endif + ++#ifdef WIN32PORT ++ run_together_start_len_ = (unsigned int)config_->retrieve_int("run-together-specified"); //FB ++#else + run_together_start_len_ = config_->retrieve_int("run-together-specified"); ++#endif + if (unconditional_run_together_ + && run_together_min_ < run_together_start_len_) + run_together_start_len_ = run_together_min_; +@@ -720,7 +778,10 @@ + } + } + ++#ifdef WIN32PORT ++#else + namespace acommon { + template class CopyPtr<aspeller::Language>; + } ++#endif + +diff -rubw aspell-0.50.4.1/modules/speller/default/speller_impl.hpp aspell-win32/modules/speller/default/speller_impl.hpp +--- aspell-0.50.4.1/modules/speller/default/speller_impl.hpp 2002-07-26 22:27:10.000000000 -0400 ++++ aspell-win32/modules/speller/default/speller_impl.hpp 2004-01-16 08:50:50.000000000 -0500 +@@ -26,7 +26,13 @@ + namespace aspeller { + + class Language; ++#ifdef WIN32PORT ++#pragma warning( disable : 4099 ) ++#endif + class SensitiveCompare; ++#ifdef WIN32PORT ++#pragma warning( default : 4099 ) ++#endif + class Suggest; + + class SpellerImpl : public Speller +diff -rubw aspell-0.50.4.1/modules/speller/default/suggest.cpp aspell-win32/modules/speller/default/suggest.cpp +--- aspell-0.50.4.1/modules/speller/default/suggest.cpp 2002-07-26 22:27:10.000000000 -0400 ++++ aspell-win32/modules/speller/default/suggest.cpp 2004-01-06 15:32:35.000000000 -0500 +@@ -167,10 +167,17 @@ + + BasicList<String> strings; + ++#ifdef WIN32PORT ++ static const bool do_count; //FB = true; ++ static const bool dont_count; //FB = false; ++ static const bool do_need_alloc;//FB = true; ++ static const bool dont_need_alloc;//FB = false; ++#else + static const bool do_count = true; + static const bool dont_count = false; + static const bool do_need_alloc = true; + static const bool dont_need_alloc = false; ++#endif + + void try_sound(const char *, int ms); + void add_nearmiss(const char * word, int ms, bool count, +@@ -279,6 +286,12 @@ + } + } + ++#ifdef WIN32PORT ++ const bool Working::do_count = true; ++ const bool Working::dont_count = false; ++ const bool Working::do_need_alloc = true; ++ const bool Working::dont_need_alloc = false; ++#endif + // + // try_others - tries to come up with possible suggestions + // +@@ -311,7 +324,11 @@ + new_word[i+1] = new_word[i]; + new_word[i] = '\0'; + ++#ifdef WIN32PORT ++ if ((bool)speller->check(new_word) && (bool)speller->check(new_word + i + 1)) { //FB uncertain ++#else + if (speller->check(new_word) && speller->check(new_word + i + 1)) { ++#endif + new_word[i] = ' '; + add_nearmiss(new_word, parms.edit_distance_weights.del2, + dont_count, do_need_alloc); +@@ -637,8 +654,13 @@ + if (dup_pair.second && + ((pos = dup_pair.first->find(' '), pos == String::npos) + ? (bool)speller->check(*dup_pair.first) ++#ifdef WIN32PORT ++ : ((bool)speller->check((String)dup_pair.first->substr(0,pos)) //FB ++ && (bool)speller->check((String)dup_pair.first->substr(pos+1))) )) //FB ++#else + : (speller->check((String)dup_pair.first->substr(0,pos)) + && speller->check((String)dup_pair.first->substr(pos+1))) )) ++#endif + near_misses_final->push_back(*dup_pair.first); + } + } else { +@@ -825,7 +847,11 @@ + l.to_normalized(key[0])) = w.extra_dis1; + } + ++#ifdef WIN32PORT ++ for (/*int*/ i = 0; i != c; ++i) { ++#else + for (int i = 0; i != c; ++i) { ++#endif + w.repl(i,i) = 0; + w.extra(i,i) = w.extra_dis1; + } +diff -rubw aspell-0.50.4.1/modules/speller/default/vector_hash-t.hpp aspell-win32/modules/speller/default/vector_hash-t.hpp +--- aspell-0.50.4.1/modules/speller/default/vector_hash-t.hpp 2002-08-11 09:58:30.000000000 -0400 ++++ aspell-win32/modules/speller/default/vector_hash-t.hpp 2004-01-06 15:32:39.000000000 -0500 +@@ -20,6 +20,8 @@ + + namespace aspeller { + ++#ifdef WIN32PORT ++#else + template <class Parms> + VectorHashTable<Parms>::FindIterator + ::FindIterator(const HashTable * ht, const key_type & k) +@@ -41,6 +43,7 @@ + } while (!parms->is_nonexistent((*vector)[i]) + && !parms->equal(parms->key((*vector)[i]), key)); + } ++#endif + + template<class Parms> + void VectorHashTable<Parms>::nonexistent_vector() { +@@ -51,7 +54,11 @@ + } + + template<class Parms> ++#ifdef WIN32PORT ++ std::pair< VectorHashTable<Parms>::iterator, bool> //FB ++#else + std::pair<typename VectorHashTable<Parms>::iterator, bool> ++#endif + VectorHashTable<Parms>::insert(const value_type & d) + { + MutableFindIterator j(this, parms_.key(d)); +@@ -167,8 +174,13 @@ + } + VectorHashTable temp(i,parms_); + iterator e = end(); ++#ifdef WIN32PORT ++ for (iterator i2 = begin(); i2 != e; ++i2) //FB ++ temp.insert(*i2); //FB ++#else + for (iterator i = begin(); i != e; ++i) + temp.insert(*i); ++#endif + swap(temp); + } + +diff -rubw aspell-0.50.4.1/modules/speller/default/vector_hash.hpp aspell-win32/modules/speller/default/vector_hash.hpp +--- aspell-0.50.4.1/modules/speller/default/vector_hash.hpp 2001-11-29 22:55:48.000000000 -0500 ++++ aspell-win32/modules/speller/default/vector_hash.hpp 2004-01-06 15:32:53.000000000 -0500 +@@ -13,6 +13,11 @@ + #ifndef __aspeller_vector_hash_hh__ + #define __aspeller_vector_hash_hh__ + ++#ifdef WIN32PORT ++# pragma warning(disable:4786) ++#include "aspellroot.h" ++#endif ++ + #include <iterator> + #include <utility> + +@@ -44,11 +49,25 @@ + class VHTIterator + { + template <class T> ++#ifdef WIN32PORT ++ bool operator== (VHTIterator<T> rhs) ++ { ++ return pos == rhs.pos; ++ } ++#else + friend bool operator== (VHTIterator<T>, VHTIterator<T>); ++#endif + #ifndef REL_OPS_POLLUTION + template <class T> ++#ifdef WIN32PORT ++ bool operator!= (VHTIterator<T> rhs) ++ { ++ return pos != rhs.pos; ++ } ++#else + friend bool operator!= (VHTIterator<T>, VHTIterator<T>); + #endif ++#endif + public: //but don't use + typedef typename Parms::TableIter TableIter; + typedef typename Parms::HashTable HashTable; +@@ -57,9 +76,12 @@ + public: + typedef std::bidirectional_iterator_tag iterator_category; + typedef typename Parms::Value value_type; ++#ifdef WIN32PORT ++#else + typedef typename std::iterator_traits<TableIter>::difference_type difference_type; + typedef typename std::iterator_traits<TableIter>::pointer pointer; + typedef typename std::iterator_traits<TableIter>::reference reference; ++#endif + + //VHTIterator vector_iterator() const {return pos;} + public: +@@ -108,21 +130,27 @@ + } + }; + ++#ifdef WIN32PORT ++#else + template <class Parms> + inline + bool operator== (VHTIterator<Parms> rhs, VHTIterator<Parms> lhs) + { + return rhs.pos == lhs.pos; + } ++#endif + + #ifndef REL_OPS_POLLUTION + ++#ifdef WIN32PORT ++#else + template <class Parms> + inline + bool operator!= (VHTIterator<Parms> rhs, VHTIterator<Parms> lhs) + { + return rhs.pos != lhs.pos; + } ++#endif + + #endif + +@@ -145,9 +173,19 @@ + // void make_nonexistent(Value &) + + template <class Parms> +- class VectorHashTable { ++ class ASPELL_API VectorHashTable { + typedef typename Parms::Vector Vector; + public: ++#ifdef WIN32PORT ++ typedef typename Vector vector_type; ++ typedef typename Parms::Vector::value_type value_type; //FB ++ typedef typename Parms::Vector::size_type size_type; //FB ++ typedef typename Parms::Vector::difference_type difference_type; //FB ++ ++ typedef typename Parms::Vector::_Tptr pointer; //FB ++ typedef typename Parms::Vector::reference reference; //FB ++ typedef typename Parms::Vector::const_reference const_reference; //FB ++#else + typedef typename Parms::Vector vector_type; + typedef typename Vector::value_type value_type; + typedef typename Vector::size_type size_type; +@@ -156,6 +194,7 @@ + typedef typename Vector::pointer pointer; + typedef typename Vector::reference reference; + typedef typename Vector::const_reference const_reference; ++#endif + + typedef typename Parms::Key key_type; + public: // but don't use +@@ -181,8 +220,13 @@ + size_type size_; + + public: // but don't use ++#ifdef WIN32PORT ++ typedef typename Parms::Vector::iterator vector_iterator; //FB ++ typedef typename Parms::Vector::const_iterator const_vector_iterator; //FB ++#else + typedef typename Vector::iterator vector_iterator; + typedef typename Vector::const_iterator const_vector_iterator; ++#endif + + private: + int hash1(const key_type &d) const { +@@ -248,10 +292,32 @@ + int i; + int hash2; + FindIterator() {} ++#ifdef WIN32PORT ++ FindIterator(const HashTable * ht, const key_type & k) : vector(&ht->vector()) //FB ++ , parms(&ht->parms()) ++ , key(k) ++ , i(ht->hash1(k)) ++ , hash2(ht->hash2(k)) ++ { ++ if (!parms->is_nonexistent((*vector)[i]) ++ && !parms->equal(parms->key((*vector)[i]), key)) ++ adv(); ++ } ++#else + FindIterator(const HashTable * ht, const key_type & k); ++#endif + public: + bool at_end() const {return parms->is_nonexistent((*vector)[i]);} ++#ifdef WIN32PORT ++ void adv(){ //FB ++ do { ++ i = (i + hash2) % vector->size(); ++ } while (!parms->is_nonexistent((*vector)[i]) ++ && !parms->equal(parms->key((*vector)[i]), key)); ++ } ++#else + void adv(); ++#endif + FindIterator & operator ++() {adv(); return *this;} + }; + friend class FindIterator; +diff -rubw aspell-0.50.4.1/modules/speller/default/writable_repl.cpp aspell-win32/modules/speller/default/writable_repl.cpp +--- aspell-0.50.4.1/modules/speller/default/writable_repl.cpp 2001-11-29 22:55:48.000000000 -0500 ++++ aspell-win32/modules/speller/default/writable_repl.cpp 2004-01-06 15:33:06.000000000 -0500 +@@ -1,5 +1,8 @@ + // Copyright 2000 by Kevin Atkinson under the terms of the LGPL + ++#ifdef WIN32PORT ++# pragma warning(disable:4786) ++#endif + #include <vector> + + #include "data_util.hpp" +@@ -141,7 +144,13 @@ + return false; + } + ++#ifdef WIN32PORT ++#pragma warning (disable : 4099) ++#endif + class WritableReplS::ElementsVirEmulImpl : public VirEnumeration<ReplacementList> { ++#ifdef WIN32PORT ++#pragma warning (default : 4099) ++#endif + private: + typedef LookupTable::const_iterator OuterItr; + typedef RealReplList::const_iterator InnerItr; +@@ -152,9 +161,17 @@ + // this assums LookupTable is non empty + ElementsVirEmulImpl (const LookupTable & c) + : outer_(c.begin()), end_(c.end()) ++#ifdef WIN32PORT ++ {if (!(outer_ == end_)) inner_ = outer_->second.begin();} //FB ++#else + {if (outer_ != end_) inner_ = outer_->second.begin();} ++#endif + ++#ifdef WIN32PORT ++ VirEnumeration<ReplacementList>* clone() const { //FB ? ++#else + ElementsVirEmulImpl * clone() const { ++#endif + return new ElementsVirEmulImpl(*this); + } + +@@ -171,7 +188,12 @@ + } + ReplacementList temp + (inner_->misspelled_word().c_str(), ++#ifdef WIN32PORT ++ new MakeVirEnumeration<StrParms<RealReplacementList::const_iterator>, //FB ++ VirEnumeration<StrParms<RealReplacementList::const_iterator>::Value> > //FB ++#else + new MakeVirEnumeration<StrParms<RealReplacementList::const_iterator> > ++#endif + (inner_->begin(), inner_->end())); + ++inner_; + return temp; +@@ -225,7 +247,12 @@ + Value deref(Iterator i) const { + return ReplacementList + (i->misspelled_word().c_str(), ++#ifdef WIN32PORT ++ new MakeVirEnumeration<StrParms<RealReplacementList::const_iterator>,//FB ++ VirEnumeration<StrParms<RealReplacementList::const_iterator>::Value> > //FB ++#else + new MakeVirEnumeration<StrParms<RealReplacementList::const_iterator> > ++#endif + (i->begin(), i->end())); + } + }; +@@ -239,7 +266,12 @@ + if (i == lookup_table->end()) { + return new MakeAlwaysEndEnumeration<ReplacementList>(); + } else { ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<ReplsWSoundslikeParms, //FB ++ VirEnumeration<ReplsWSoundslikeParms::Value> > //FB ++#else + return new MakeVirEnumeration<ReplsWSoundslikeParms> ++#endif + (i->second.begin(), ReplsWSoundslikeParms(i->second.end())); + } + } +@@ -251,7 +283,12 @@ + const RealReplList * p = + reinterpret_cast<const RealReplList *>(soundslike.word_list_pointer); + ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<ReplsWSoundslikeParms, //FB ++ VirEnumeration<ReplsWSoundslikeParms::Value> >(p->begin(), p->end()); //FB ++#else + return new MakeVirEnumeration<ReplsWSoundslikeParms>(p->begin(), p->end()); ++#endif + + } + +@@ -270,7 +307,12 @@ + + WritableReplS::VirSoundslikeEmul * + WritableReplS::soundslike_elements() const { ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<SoundslikeElementsParms, //FB ++ VirEnumeration<SoundslikeElementsParms::Value> > //FB ++#else + return new MakeVirEnumeration<SoundslikeElementsParms> ++#endif + (lookup_table->begin(),SoundslikeElementsParms(lookup_table->end())); + } + +@@ -281,7 +323,11 @@ + LookupTable::iterator i = lookup_table->begin(); + LookupTable::iterator e = lookup_table->end(); + ++#ifdef WIN32PORT ++ for (;!(i == e); ++i) { //FB ++#else + for (;i != e; ++i) { ++#endif + for (RealReplList::iterator j = i->second.begin(); + j != i->second.end(); + ++j) +diff -rubw aspell-0.50.4.1/modules/speller/default/writable_ws.cpp aspell-win32/modules/speller/default/writable_ws.cpp +--- aspell-0.50.4.1/modules/speller/default/writable_ws.cpp 2001-11-29 22:55:48.000000000 -0500 ++++ aspell-win32/modules/speller/default/writable_ws.cpp 2004-01-16 08:51:41.000000000 -0500 +@@ -1,5 +1,8 @@ + // Copyright 2000 by Kevin Atkinson under the terms of the LGPL + ++#ifdef WIN32PORT ++# pragma warning(disable:4786) ++#endif + #include <vector> + + #include "copy_ptr-t.hpp" +@@ -92,7 +95,12 @@ + + WritableWS::VirEmul * WritableWS::detailed_elements() const { + ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<ElementsParms, //FB ++ VirEnumeration<ElementsParms::Value> > //FB ++#else + return new MakeVirEnumeration<ElementsParms> ++#endif + (word_lookup->begin(),ElementsParms(word_lookup->end())); + } + +@@ -153,7 +161,11 @@ + + RealSoundslikeWordList::const_iterator j; + ++#ifdef WIN32PORT ++ for (;!(i == e); ++i) { //FB (strange) ++#else + for (;i != e; ++i) { ++#endif + for (j = i->second.begin(); j != i->second.end(); ++j) { + out << *j << '\n'; + } +@@ -185,7 +197,11 @@ + { + pair<WordLookup::iterator, WordLookup::iterator> + p(word_lookup->equal_range(SimpleString(word,1))); ++#ifdef WIN32PORT ++ while (!(p.first == p.second)) { //FB ++#else + while (p.first != p.second) { ++#endif + if (c(word,p.first->c_str())) + return p.first->c_str(); + ++p.first; +@@ -212,7 +228,12 @@ + if (i == soundslike_lookup.end()) { + return new MakeAlwaysEndEnumeration<BasicWordInfo>(); + } else { ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<SoundslikeWordsParms, ++ VirEnumeration<SoundslikeWordsParms::Value> > ++#else + return new MakeVirEnumeration<SoundslikeWordsParms> ++#endif + (i->second.begin(), SoundslikeWordsParms(i->second.end())); + } + } +@@ -232,7 +253,12 @@ + + + WritableWS::VirSoundslikeEmul * WritableWS::soundslike_elements() const { ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<SoundslikeElementsParms, ++ VirEnumeration<SoundslikeElementsParms::Value> > //FB ++#else + return new MakeVirEnumeration<SoundslikeElementsParms> ++#endif + (soundslike_lookup.begin(), soundslike_lookup.end()); + } + +@@ -243,7 +269,12 @@ + = reinterpret_cast<const RealSoundslikeWordList *> + (word.word_list_pointer); + ++#ifdef WIN32PORT ++ return new MakeVirEnumeration<SoundslikeWordsParms, //FB ++ VirEnumeration<SoundslikeWordsParms::Value> > //FB ++#else + return new MakeVirEnumeration<SoundslikeWordsParms> ++#endif + (temp->begin(), SoundslikeWordsParms(temp->end())); + } + +diff -rubw aspell-0.50.4.1/prog/aspell.cpp aspell-win32/prog/aspell.cpp +--- aspell-0.50.4.1/prog/aspell.cpp 2003-10-06 23:45:24.000000000 -0400 ++++ aspell-win32/prog/aspell.cpp 2004-01-06 15:33:21.000000000 -0500 +@@ -65,22 +65,49 @@ + do{PosibErrBase pe(command);\ + if(pe.has_err()){CERR<<"Error: "<< pe.get_err()->mesg << "\n"; exit(1);}\ + } while(false) ++#ifdef WIN32PORT ++#define EXIT_ON_ERR_SET(command, type, var)\ ++ typedef type temp_t;\ ++ temp_t var;\ ++ do{PosibErr<temp_t> pe(command);\ ++ if(pe.has_err()){CERR<<"Error: "<< pe.get_err()->mesg << "\n"; exit(1);}\ ++ else {var=pe.data;}\ ++ } while(false) ++#else + #define EXIT_ON_ERR_SET(command, type, var)\ + type var;\ + do{PosibErr<type> pe(command);\ + if(pe.has_err()){CERR<<"Error: "<< pe.get_err()->mesg << "\n"; exit(1);}\ + else {var=pe.data;}\ + } while(false) ++#endif ++#define EXIT_ON_ERR_SET(command, type, var)\ ++ typedef type temp_t;\ ++ temp_t var;\ ++ do{PosibErr<temp_t> pe(command);\ ++ if(pe.has_err()){CERR<<"Error: "<< pe.get_err()->mesg << "\n"; exit(1);}\ ++ else {var=pe.data;}\ ++ } while(false) + #define BREAK_ON_ERR(command) \ + do{PosibErrBase pe(command);\ + if(pe.has_err()){CERR<<"Error: "<< pe.get_err()->mesg << "\n"; break;}\ + } while(false) ++#ifdef WIN32PORT ++#define BREAK_ON_ERR_SET(command, type, var)\ ++ typedef type temp_t;\ ++ temp_t var;\ ++ do{PosibErr<temp_t> pe(command);\ ++ if(pe.has_err()){CERR<<"Error: "<< pe.get_err()->mesg << "\n"; break;}\ ++ else {var=pe.data;}\ ++ } while(false) ++#else + #define BREAK_ON_ERR_SET(command, type, var)\ + type var;\ + do{PosibErr<type> pe(command);\ + if(pe.has_err()){CERR<<"Error: "<< pe.get_err()->mesg << "\n"; break;}\ + else {var=pe.data;}\ + } while(false) ++#endif + + + ///////////////////////////////////////////////////////// +@@ -183,7 +210,11 @@ + return i; + } + ++#ifdef WIN32PORT ++int cmdline_main (int argc, char *argv[]) ++#else + int main (int argc, const char *argv[]) ++#endif + { + EXIT_ON_ERR(options->read_in_settings()); + +@@ -283,7 +314,15 @@ + // + // perform the requisted action + // ++#ifdef WIN32PORT ++ // Evidently, the assignment somehow references memory that isn't available ++ // when the destructor for the String is called. This change makes sure that ++ // the string gets its own copy of the data. -- TL ++ String action_str; ++ action_str.append(args.front()); ++#else + String action_str = args.front(); ++#endif + args.pop_front(); + if (action_str == "help") + print_help(); +@@ -319,7 +358,15 @@ + CERR << "Error: Unknown Action: " << action_str << "\n"; + return 1; + } ++#ifdef WIN32PORT ++ // Evidently, the assignment somehow references memory that isn't available ++ // when the destructor for the String is called. This change makes sure that ++ // the string gets its own copy of the data. -- TL ++ String what_str; ++ what_str.append(args.front()); ++#else + String what_str = args.front(); ++#endif + args.pop_front(); + if (what_str == "config") + config(); +@@ -1004,7 +1051,11 @@ + String data; + public: + IstreamVirEnumeration(FStream & i) : in(&i) {} ++#ifdef WIN32PORT ++ StringEnumeration * clone() const { ++#else + IstreamVirEnumeration * clone() const { ++#endif + return new IstreamVirEnumeration(*this); + } + void assign (const StringEnumeration * other) { +diff -rubw aspell-0.50.4.1/prog/checker_string.cpp aspell-win32/prog/checker_string.cpp +--- aspell-0.50.4.1/prog/checker_string.cpp 2003-06-05 14:35:02.000000000 -0400 ++++ aspell-win32/prog/checker_string.cpp 2004-01-06 15:33:24.000000000 -0500 +@@ -93,7 +93,11 @@ + correct = true; + } + if (!correct) ++#ifdef WIN32PORT ++ correct = aspell_speller_check(speller_, &*word_begin_, word_size_) != 0; ++#else + correct = aspell_speller_check(speller_, &*word_begin_, word_size_); ++#endif + diff_ += word_size_ - tok_.len; + tok_.len = word_size_; + if (!correct) +diff -rubw aspell-0.50.4.1/prog/compress.c aspell-win32/prog/compress.c +--- aspell-0.50.4.1/prog/compress.c 2002-08-31 15:51:12.000000000 -0400 ++++ aspell-win32/prog/compress.c 2004-01-06 15:33:27.000000000 -0500 +@@ -52,7 +52,11 @@ + else return 1; + } + ++#if WIN32PORT ++int compress_main (int argc, char *argv[]) { ++#else + int main (int argc, const char *argv[]) { ++#endif + + if (argc != 2) { + +Only in aspell-win32: settings.h + |