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