Attachment #139576 for bug #203701

View | Details | Raw Unified | Return to bug 203701
Collapse All | Expand All

Lines 238-244 Link Here

(-)aspell-0.60.5-orig/common/convert.cpp (-1 / +1 lines)
238	}	238	}
239		239
240	template <class T>	240	template <class T>
241	static void free_norm_table(NormTable<T> * d)	241	void free_norm_table(NormTable<T> * d)
242	{	242	{
243	for (T * cur = d->data; cur != d->end; ++cur) {	243	for (T * cur = d->data; cur != d->end; ++cur) {
244	if (cur->sub_table)	244	if (cur->sub_table)




    }

    char & operator[] (size_t pos) {return begin_[pos];}
    char operator[] (size_t pos) const {return begin_[pos];}

    char & back() {return end_[-1];}
    char back() const {return end_[-1];}

    void clear() {end_ = begin_;}



namespace std
{
  template<> inline void swap(acommon::String & x, acommon::String & y) {return x.swap(y);}
}

#endif

Lines 193-199 Link Here

(-)aspell-0.60.5-orig/modules/speller/default/affix.cpp (-1 / +1 lines)
193	typedef const Conds * Value;	193	typedef const Conds * Value;
194	typedef const char * Key;	194	typedef const char * Key;
195	static const bool is_multi = false;	195	static const bool is_multi = false;
196	hash<const char *> hfun;	196	acommon::hash<const char *> hfun;
197	size_t hash(const char * s) {return hfun(s);}	197	size_t hash(const char * s) {return hfun(s);}
198	bool equal(const char * x, const char * y) {return strcmp(x,y) == 0;}	198	bool equal(const char * x, const char * y) {return strcmp(x,y) == 0;}
199	const char * key(const Conds * c) {return c->str;}	199	const char * key(const Conds * c) {return c->str;}

Lines 107-113 Link Here

(-)aspell-0.60.5-orig/modules/speller/default/affix.hpp (-1 / +1 lines)
107	{	107	{
108	return expand(word,aff,buf,0);	108	return expand(word,aff,buf,0);
109	}	109	}
110	WordAff * expand_suffix(ParmString word, const unsigned char * new_aff,	110	WordAff * expand_suffix(ParmString word, const unsigned char * aff,
111	ObjStack &, int limit = INT_MAX,	111	ObjStack &, int limit = INT_MAX,
112	unsigned char * new_aff = 0, WordAff * * * l = 0,	112	unsigned char * new_aff = 0, WordAff * * * l = 0,
113	ParmString orig_word = 0) const;	113	ParmString orig_word = 0) const;

Lines 726-732 Link Here

(-)aspell-0.60.5-orig/modules/speller/default/readonly_ws.cpp (-1 / +1 lines)
726	struct WordLookupParms {	726	struct WordLookupParms {
727	const char * block_begin;	727	const char * block_begin;
728	WordLookupParms() {}	728	WordLookupParms() {}
729	typedef Vector<u32int> Vector;	729	typedef acommon::Vector<u32int> Vector;
730	typedef u32int Value;	730	typedef u32int Value;
731	typedef const char * Key;	731	typedef const char * Key;
732	static const bool is_multi = false;	732	static const bool is_multi = false;




  return i;
}

static void line_buffer() {
#ifndef WIN32
  // set up stdin and stdout to be line buffered
  assert(setvbuf(stdin, 0, _IOLBF, 0) == 0); 
  assert(setvbuf(stdout, 0, _IOLBF, 0) == 0);
#endif
}

Conv dconv;
Conv uiconv;



void pipe() 
{
  line_buffer();
  // set up stdin and stdout to be line buffered
  assert(setvbuf(stdin, 0, _IOLBF, 0) == 0); 
  assert(setvbuf(stdout, 0, _IOLBF, 0) == 0);
#endif

  bool terse_mode = true;
  bool do_time = options->retrieve_bool("time");

  Conv oconv(setup_conv(lang, options));
  String word;
  String sl;
  line_buffer();
  while (CIN.getline(word)) {
    const char * w = iconv(word);
    lang->LangImpl::to_soundslike(sl, w);

  Conv oconv(setup_conv(lang, options));
  String word;
  GuessInfo gi;
  line_buffer();
  while (CIN.getline(word)) {
    lang->munch(iconv(word), &gi);
    COUT << word;

  String word, buf;
  ObjStack exp_buf;
  WordAff * exp_list;
  line_buffer();
  while (CIN.getline(word)) {
    buf = word;
    char * w = iconv(buf.mstr(), buf.size());

  String word;
  String base;
  String affs;
  line_buffer();
  while (CIN.getline(word)) {
    word = iconv(word);


  typedef SML_WordEntry Value;
  typedef const char * Key;
  static const bool is_multi = false;
  acommon::hash<const char *> hash;
  bool equal(Key x, Key y) {return strcmp(x,y) == 0;}
  Key key(const Value & v) {return v.word;}
};

  typedef CML_Entry Value;
  typedef const char * Key;
  static const bool is_multi = true;
  acommon::hash<const char *> hash;
  bool equal(Key x, Key y) {return strcmp(x,y) == 0;}
  Key key(const Value & v) {return v.word;}
};

Return to bug 203701

Lines 129-138 Link Here

(-)aspell-0.60.5-orig/common/string.hpp (-3 / +3 lines)
129	}	129	}
130		130
131	char & operator[] (size_t pos) {return begin_[pos];}	131	char & operator[] (size_t pos) {return begin_[pos];}
132	const char operator[] (size_t pos) const {return begin_[pos];}	132	char operator[] (size_t pos) const {return begin_[pos];}
133		133
134	char & back() {return end_[-1];}	134	char & back() {return end_[-1];}
135	const char back() const {return end_[-1];}	135	char back() const {return end_[-1];}
136		136
137	void clear() {end_ = begin_;}	137	void clear() {end_ = begin_;}
138		138
Lines 492-498 Link Here
492		492
493	namespace std	493	namespace std
494	{	494	{
495	template<> static inline void swap(acommon::String & x, acommon::String & y) {return x.swap(y);}	495	template<> inline void swap(acommon::String & x, acommon::String & y) {return x.swap(y);}
496	}	496	}
497		497
498	#endif	498	#endif

Lines 239-244 Link Here

(-)aspell-0.60.5-orig/prog/aspell.cpp (-7 / +15 lines)
239	return i;	239	return i;
240	}	240	}
241		241
		242	static void line_buffer() {
		243	#ifndef WIN32
		244	// set up stdin and stdout to be line buffered
		245	assert(setvbuf(stdin, 0, _IOLBF, 0) == 0);
		246	assert(setvbuf(stdout, 0, _IOLBF, 0) == 0);
		247	#endif
		248	}
		249
242	Conv dconv;	250	Conv dconv;
243	Conv uiconv;	251	Conv uiconv;
244		252
Lines 686-696 Link Here
686		694
687	void pipe()	695	void pipe()
688	{	696	{
689	#ifndef WIN32	697	line_buffer();
690	// set up stdin and stdout to be line buffered
691	assert(setvbuf(stdin, 0, _IOLBF, 0) == 0);
692	assert(setvbuf(stdout, 0, _IOLBF, 0) == 0);
693	#endif
694		698
695	bool terse_mode = true;	699	bool terse_mode = true;
696	bool do_time = options->retrieve_bool("time");	700	bool do_time = options->retrieve_bool("time");
Lines 1651-1656 Link Here
1651	Conv oconv(setup_conv(lang, options));	1655	Conv oconv(setup_conv(lang, options));
1652	String word;	1656	String word;
1653	String sl;	1657	String sl;
		1658	line_buffer();
1654	while (CIN.getline(word)) {	1659	while (CIN.getline(word)) {
1655	const char * w = iconv(word);	1660	const char * w = iconv(word);
1656	lang->LangImpl::to_soundslike(sl, w);	1661	lang->LangImpl::to_soundslike(sl, w);
Lines 1675-1680 Link Here
1675	Conv oconv(setup_conv(lang, options));	1680	Conv oconv(setup_conv(lang, options));
1676	String word;	1681	String word;
1677	GuessInfo gi;	1682	GuessInfo gi;
		1683	line_buffer();
1678	while (CIN.getline(word)) {	1684	while (CIN.getline(word)) {
1679	lang->munch(iconv(word), &gi);	1685	lang->munch(iconv(word), &gi);
1680	COUT << word;	1686	COUT << word;
Lines 1713-1718 Link Here
1713	String word, buf;	1719	String word, buf;
1714	ObjStack exp_buf;	1720	ObjStack exp_buf;
1715	WordAff * exp_list;	1721	WordAff * exp_list;
		1722	line_buffer();
1716	while (CIN.getline(word)) {	1723	while (CIN.getline(word)) {
1717	buf = word;	1724	buf = word;
1718	char * w = iconv(buf.mstr(), buf.size());	1725	char * w = iconv(buf.mstr(), buf.size());
Lines 1799-1804 Link Here
1799	String word;	1806	String word;
1800	String base;	1807	String base;
1801	String affs;	1808	String affs;
		1809	line_buffer();
1802	while (CIN.getline(word)) {	1810	while (CIN.getline(word)) {
1803	word = iconv(word);	1811	word = iconv(word);
1804		1812
Lines 1882-1888 Link Here
1882	typedef SML_WordEntry Value;	1890	typedef SML_WordEntry Value;
1883	typedef const char * Key;	1891	typedef const char * Key;
1884	static const bool is_multi = false;	1892	static const bool is_multi = false;
1885	hash<const char *> hash;	1893	acommon::hash<const char *> hash;
1886	bool equal(Key x, Key y) {return strcmp(x,y) == 0;}	1894	bool equal(Key x, Key y) {return strcmp(x,y) == 0;}
1887	Key key(const Value & v) {return v.word;}	1895	Key key(const Value & v) {return v.word;}
1888	};	1896	};
Lines 2033-2039 Link Here
2033	typedef CML_Entry Value;	2041	typedef CML_Entry Value;
2034	typedef const char * Key;	2042	typedef const char * Key;
2035	static const bool is_multi = true;	2043	static const bool is_multi = true;
2036	hash<const char *> hash;	2044	acommon::hash<const char *> hash;
2037	bool equal(Key x, Key y) {return strcmp(x,y) == 0;}	2045	bool equal(Key x, Key y) {return strcmp(x,y) == 0;}
2038	Key key(const Value & v) {return v.word;}	2046	Key key(const Value & v) {return v.word;}
2039	};	2047	};