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::Parms> ::reset(Error*, CopyPtr::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 +#ifdef WIN32PORT +#include "generic_copy_ptr.hpp" +#else #include "generic_copy_ptr-t.hpp" +#endif namespace acommon { +#ifdef WIN32PORT +#else template inline T * ClonePtr::Parms::clone(const T * ptr) const { return ptr->clone(); @@ -39,6 +45,7 @@ inline void ClonePtr::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 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 #include +#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(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(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(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 keyinfo(ParmString key) const; + ASPELL_API PosibErr 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 get_default (ParmString key) const; + ASPELL_API PosibErr get_default (ParmString key) const; - PosibErr retrieve (ParmString key) const; + ASPELL_API PosibErr retrieve (ParmString key) const; - bool have (ParmString key) const; + ASPELL_API bool have (ParmString key) const; - PosibErr retrieve_list (ParmString key, MutableContainer *) const; - PosibErr retrieve_bool (ParmString key) const; - PosibErr retrieve_int (ParmString key) const; + ASPELL_API PosibErr retrieve_list (ParmString key, MutableContainer *) const; + ASPELL_API PosibErr retrieve_bool (ParmString key) const; + ASPELL_API PosibErr retrieve_int (ParmString key) const; - PosibErr replace (ParmString, ParmString); - PosibErr remove (ParmString); + ASPELL_API PosibErr replace (ParmString, ParmString); + ASPELL_API PosibErr 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 read_in_settings(const Config * override = 0); + ASPELL_API PosibErr read_in_settings(const Config * override = 0); - PosibErr read_in(IStream & in); - PosibErr read_in_file(ParmString file); - PosibErr read_in_string(ParmString str); + ASPELL_API PosibErr read_in(IStream & in); + ASPELL_API PosibErr read_in_file(ParmString file); + ASPELL_API PosibErr 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 +#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(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 T * CopyPtr::Parms::clone(const T * ptr) const { return new T(*ptr); @@ -32,6 +38,7 @@ void CopyPtr::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 - 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 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 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 new_document_checker(Speller *); + ASPELL_API PosibErr 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 struct MakeAlwaysEndEnumerationParms { Value end_state() const {return Value();} }; +#ifdef WIN32PORT +#else template struct MakeAlwaysEndEnumerationParms { Value * end_state() const {return 0;} }; +#endif template class MakeAlwaysEndEnumeration : public VirEnumeration { MakeAlwaysEndEnumerationParms parms_; public: +#ifdef WIN32PORT + /*MakeAlwaysEndEnumeration*/VirEnumeration * clone() const {//FB +#else MakeAlwaysEndEnumeration * clone() const { +#endif return new MakeAlwaysEndEnumeration(*this); } void assign(const VirEnumeration * 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 and not #include +#ifdef WIN32PORT +#include "aspellroot.h" +#include //FB (for _access) +#else #include +#endif #include @@ -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 open_file_readlock(FStream& in, ParmString file); - PosibErr open_file_writelock(FStream & in, ParmString file); + time_t ASPELL_API get_modification_time(FStream & f); + PosibErr ASPELL_API open_file_readlock(FStream& in, ParmString file); + PosibErr 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 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 +#ifdef WIN32PORT + std::pair< HashTable

::iterator,bool> HashTable

::insert(const Value & to_insert) //FB +#else std::pair::iterator,bool> HashTable

::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(put_me_here,false); Node * new_node = node_pool_.new_node(); if (new_node == 0) { @@ -152,7 +160,11 @@ } template +#ifdef WIN32PORT + std::pair::iterator, HashTable

::iterator>//FB +#else std::pair::iterator, typename HashTable

::iterator> +#endif HashTable

::equal_range_i(const Key & to_find, int & c) { c = 0; @@ -174,6 +186,10 @@ template void HashTable

::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 insert(const value_type &); void erase(iterator); size_type erase(const key_type &); @@ -258,9 +262,17 @@ template 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 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 #endif +#ifdef WIN32PORT +#include //FB +#include //FB +#else #include +#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 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 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 +#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 #include +#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 #include "posib_err.hpp" +#ifdef WIN32PORT +using namespace std; // FB +#endif namespace acommon { String & String::operator= (const PosibErr & 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 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 & other) : std::string(other.data) {} +#endif inline String & String::operator= (const PosibErr & 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 reload_filters(Speller * m); + ASPELL_API PosibErr reload_filters(Speller * m); - PosibErr new_speller(Config * c); + ASPELL_API PosibErr 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 > 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 & other); String & operator= (const char * s) { std::string::operator= (s); +#endif return *this; } inline String & operator= (const PosibErr & 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 & s); + ASPELL_API /*inline*/ String & operator= (const PosibErr & 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 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 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 +#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 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 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 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 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 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 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 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 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 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(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(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 +#ifdef WIN32PORT +#else #include +#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 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 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(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 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 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 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 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 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 @@

save-repl
(boolean) save the replacement word list on save -allkeyboard (file) the base name of the keyboard definition +all +
+
keyboard
+
(file) the base name of the keyboard definition file to use (see section 4.4.3)
sug-mode
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 +#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 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 add_data_set(ParmString file_name, + PosibErr 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 create_default_readonly_word_set(StringEnumeration * els, + ASPELL_API BasicWordSet * new_default_readonly_word_set(); + ASPELL_API PosibErr 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(num); //FB + char_data >> num; to_upper_[j] = static_cast(num); //FB + char_data >> num; to_title_[j] = static_cast(num); //FB + char_data >> num; to_sl_[j] = static_cast(num); //FB + char_data >> num; to_stripped_[j] = static_cast(num); //FB + char_data >> num; de_accent_[j] = static_cast(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(num); char_data >> num; to_stripped_[i] = static_cast(num); char_data >> num; de_accent_[i] = static_cast(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 setup(ParmString lang, Config *); + ASPELL_API PosibErr 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 >(wss.begin(), wss.end());//FB +#else return new MakeVirEnumeration(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 @@ -33,7 +36,11 @@ char c = lang->to_sl(static_cast(i)); if (c) chars_set[static_cast(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(i); @@ -86,7 +93,11 @@ if (lang->is_alpha(c) || lang->special(c).any()) chars_set[static_cast(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(i); @@ -158,11 +169,19 @@ chars_set[static_cast(*j)] = true; } } +#ifdef WIN32PORT + for (int k = 0; k != 256; ++k) //FB + { + if (chars_set[k]) //FB + chars_list += static_cast(k); //FB + } +#else for (int i = 0; i != 256; ++i) { if (chars_set[i]) chars_list += static_cast(i); } +#endif return chars_list; } @@ -207,6 +226,9 @@ } +#ifdef WIN32PORT +#else namespace acommon { template class ClonePtr; } +#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 using std::vector; @@ -175,7 +178,10 @@ typedef BlockVector 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 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 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 > +#else return new MakeVirEnumeration +#endif (word_lookup.begin(), ElementsParms(block)); } @@ -512,12 +525,22 @@ if (use_soundslike) { +#ifdef WIN32PORT + return new MakeVirEnumeration > //FB +#else return new MakeVirEnumeration +#endif (soundslike_lookup.begin(), soundslike_block); } else { +#ifdef WIN32PORT + return new MakeVirEnumeration > //FB +#else return new MakeVirEnumeration +#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 >(i, block); +#else return new MakeVirEnumeration(i, block); +#endif } @@ -554,7 +582,12 @@ const u32int * end = reinterpret_cast(w.soundslike - 2); u16int size = *reinterpret_cast(end); +#ifdef WIN32PORT + return new MakeVirEnumeration > +#else return new MakeVirEnumeration +#endif (end - size, SoundslikeWordsParms(word_block, end)); } else { @@ -584,7 +617,11 @@ typedef vector 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 WordHash; @@ -610,7 +650,11 @@ }; typedef pair Value; typedef vector 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 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 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(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(run_together_min_)) { @@ -277,8 +281,12 @@ } SpellerImpl::WordLists SpellerImpl::wordlists() const { - return WordLists(MakeVirEnumeration +#ifdef WIN32PORT + return WordLists(MakeVirEnumeration > //FB (wls_->begin(), DataSetCollection::Parms(wls_->end()))); +#else + return WordLists(MakeVirEnumeration +#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 PosibErr 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; } +#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 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 VectorHashTable::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 void VectorHashTable::nonexistent_vector() { @@ -51,7 +54,11 @@ } template +#ifdef WIN32PORT + std::pair< VectorHashTable::iterator, bool> //FB +#else std::pair::iterator, bool> +#endif VectorHashTable::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 #include @@ -44,11 +49,25 @@ class VHTIterator { template +#ifdef WIN32PORT + bool operator== (VHTIterator rhs) + { + return pos == rhs.pos; + } +#else friend bool operator== (VHTIterator, VHTIterator); +#endif #ifndef REL_OPS_POLLUTION template +#ifdef WIN32PORT + bool operator!= (VHTIterator rhs) + { + return pos != rhs.pos; + } +#else friend bool operator!= (VHTIterator, VHTIterator); #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::difference_type difference_type; typedef typename std::iterator_traits::pointer pointer; typedef typename std::iterator_traits::reference reference; +#endif //VHTIterator vector_iterator() const {return pos;} public: @@ -108,21 +130,27 @@ } }; +#ifdef WIN32PORT +#else template inline bool operator== (VHTIterator rhs, VHTIterator lhs) { return rhs.pos == lhs.pos; } +#endif #ifndef REL_OPS_POLLUTION +#ifdef WIN32PORT +#else template inline bool operator!= (VHTIterator rhs, VHTIterator lhs) { return rhs.pos != lhs.pos; } +#endif #endif @@ -145,9 +173,19 @@ // void make_nonexistent(Value &) template - 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 #include "data_util.hpp" @@ -141,7 +144,13 @@ return false; } +#ifdef WIN32PORT +#pragma warning (disable : 4099) +#endif class WritableReplS::ElementsVirEmulImpl : public VirEnumeration { +#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* 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, //FB + VirEnumeration::Value> > //FB +#else new MakeVirEnumeration > +#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,//FB + VirEnumeration::Value> > //FB +#else new MakeVirEnumeration > +#endif (i->begin(), i->end())); } }; @@ -239,7 +266,12 @@ if (i == lookup_table->end()) { return new MakeAlwaysEndEnumeration(); } else { +#ifdef WIN32PORT + return new MakeVirEnumeration > //FB +#else return new MakeVirEnumeration +#endif (i->second.begin(), ReplsWSoundslikeParms(i->second.end())); } } @@ -251,7 +283,12 @@ const RealReplList * p = reinterpret_cast(soundslike.word_list_pointer); +#ifdef WIN32PORT + return new MakeVirEnumeration >(p->begin(), p->end()); //FB +#else return new MakeVirEnumeration(p->begin(), p->end()); +#endif } @@ -270,7 +307,12 @@ WritableReplS::VirSoundslikeEmul * WritableReplS::soundslike_elements() const { +#ifdef WIN32PORT + return new MakeVirEnumeration > //FB +#else return new MakeVirEnumeration +#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 #include "copy_ptr-t.hpp" @@ -92,7 +95,12 @@ WritableWS::VirEmul * WritableWS::detailed_elements() const { +#ifdef WIN32PORT + return new MakeVirEnumeration > //FB +#else return new MakeVirEnumeration +#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 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(); } else { +#ifdef WIN32PORT + return new MakeVirEnumeration > +#else return new MakeVirEnumeration +#endif (i->second.begin(), SoundslikeWordsParms(i->second.end())); } } @@ -232,7 +253,12 @@ WritableWS::VirSoundslikeEmul * WritableWS::soundslike_elements() const { +#ifdef WIN32PORT + return new MakeVirEnumeration > //FB +#else return new MakeVirEnumeration +#endif (soundslike_lookup.begin(), soundslike_lookup.end()); } @@ -243,7 +269,12 @@ = reinterpret_cast (word.word_list_pointer); +#ifdef WIN32PORT + return new MakeVirEnumeration > //FB +#else return new MakeVirEnumeration +#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 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 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 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 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 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