From fb6d89e9b87eae301c0b09d3f148ccf1841c66d2 Mon Sep 17 00:00:00 2001 From: Kevin Atkinson Date: Sun, 25 Aug 2019 21:59:04 -0400 Subject: [PATCH 1/4] suggest: fix bug in run-together code --- modules/speller/default/suggest.cpp | 2 +- test/suggest.mk | 4 +++- test/suggest/mkmk | 9 +++++++++ 3 files changed, 13 insertions(+), 2 deletions(-) diff --git a/modules/speller/default/suggest.cpp b/modules/speller/default/suggest.cpp index 43b6a01f..299b0d98 100644 --- a/modules/speller/default/suggest.cpp +++ b/modules/speller/default/suggest.cpp @@ -245,7 +245,7 @@ namespace { bool check_word_s(ParmString word, CheckInfo * ci); unsigned check_word(char * word, char * word_end, CheckInfo * ci, /* it WILL modify word */ - unsigned pos = 1); + unsigned pos = 0); void try_word_c(char * word, char * word_end, const ScoreInfo & inf); void try_word(char * word, char * word_end, const ScoreInfo & inf) { diff --git a/test/suggest.mk b/test/suggest.mk index bf43aa92..bfa0bb4a 100644 --- a/test/suggest.mk +++ b/test/suggest.mk @@ -103,4 +103,6 @@ suggest-05-common-normal-nokbd:: prep suggest/comp suggest/05-common-normal-nokbd-expect.res tmp/05-common-normal-nokbd-actual.res 1 > tmp/05-common-normal-nokbd.diff rm tmp/05-common-normal-nokbd.diff echo "ok (suggest reg. 05-common normal nokbd)" >> test-res -suggest:: suggest-00-special-ultra suggest-00-special-fast suggest-00-special-normal suggest-00-special-slow suggest-00-special-bad-spellers suggest-00-special-ultra-nokbd suggest-00-special-normal-nokbd suggest-02-orig-ultra suggest-02-orig-fast suggest-02-orig-normal suggest-02-orig-slow suggest-02-orig-bad-spellers suggest-02-orig-ultra-nokbd suggest-02-orig-normal-nokbd suggest-05-common-ultra suggest-05-common-fast suggest-05-common-normal suggest-05-common-slow suggest-05-common-ultra-nokbd suggest-05-common-normal-nokbd +suggest-run-together:: prep + echo 'hotdoog' | inst/bin/aspell -a --run-together --run-together-limit=2 | grep -q hotdog +suggest:: suggest-00-special-ultra suggest-00-special-fast suggest-00-special-normal suggest-00-special-slow suggest-00-special-bad-spellers suggest-00-special-ultra-nokbd suggest-00-special-normal-nokbd suggest-02-orig-ultra suggest-02-orig-fast suggest-02-orig-normal suggest-02-orig-slow suggest-02-orig-bad-spellers suggest-02-orig-ultra-nokbd suggest-02-orig-normal-nokbd suggest-05-common-ultra suggest-05-common-fast suggest-05-common-normal suggest-05-common-slow suggest-05-common-ultra-nokbd suggest-05-common-normal-nokbd suggest-run-together diff --git a/test/suggest/mkmk b/test/suggest/mkmk index 44f1c6b4..9a59f8a2 100755 --- a/test/suggest/mkmk +++ b/test/suggest/mkmk @@ -29,6 +29,15 @@ suggest-$f-${mode}-nokbd:: prep $targets .= " suggest-$f-${mode}-nokbd"; } } + +print <<"---"; +suggest-run-together:: prep + echo 'hotdoog' | inst/bin/aspell -a --run-together --run-together-limit=2 | grep -q hotdog +--- +$targets .= " suggest-run-together"; + $targets .= "\n"; print $targets; + + From 24a5702e3dea630c440b40b0a8e6ccbf210a8726 Mon Sep 17 00:00:00 2001 From: Kevin Atkinson Date: Mon, 26 Aug 2019 02:44:03 -0400 Subject: [PATCH 2/4] suggest: parameterize try_word_n --- modules/speller/default/suggest.cpp | 40 +++++++++++++++++++++-------- 1 file changed, 29 insertions(+), 11 deletions(-) diff --git a/modules/speller/default/suggest.cpp b/modules/speller/default/suggest.cpp index 299b0d98..44cbc2f0 100644 --- a/modules/speller/default/suggest.cpp +++ b/modules/speller/default/suggest.cpp @@ -241,19 +241,16 @@ namespace { }; MutableString form_word(CheckInfo & ci); - void try_word_n(ParmString str, const ScoreInfo & inf); + template + void try_word_n(ParmString str, Adder &); + struct PassthroughAdder; bool check_word_s(ParmString word, CheckInfo * ci); unsigned check_word(char * word, char * word_end, CheckInfo * ci, /* it WILL modify word */ unsigned pos = 0); void try_word_c(char * word, char * word_end, const ScoreInfo & inf); - void try_word(char * word, char * word_end, const ScoreInfo & inf) { - if (sp->unconditional_run_together_) - try_word_c(word,word_end,inf); - else - try_word_n(word,inf); - } + void try_word(char * word, char * word_end, const ScoreInfo & inf); void try_word(char * word, char * word_end, int score) { ScoreInfo inf; inf.word_score = score; @@ -483,7 +480,27 @@ namespace { return MutableString(tmp,wlen); } - void Working::try_word_n(ParmString str, const ScoreInfo & inf) + struct Working::PassthroughAdder { + Working * wk; + const ScoreInfo & si; + PassthroughAdder(Working * wk, const ScoreInfo & si) : wk(wk), si(si) {} + void operator()(char * word, unsigned word_size) + {wk->add_nearmiss(word, word_size, 0, si);} + void operator()(SpellerImpl::WS::const_iterator i, const WordEntry & w) + {wk->add_nearmiss_w(i, w, si);} + }; + + void Working::try_word(char * word, char * word_end, const ScoreInfo & inf) { + if (sp->unconditional_run_together_) + try_word_c(word,word_end,inf); + else { + PassthroughAdder adder(this,inf); + try_word_n(ParmString(word,word_end-word),adder); + } + } + + template + void Working::try_word_n(ParmString str, Adder & add) { String word; String buf; @@ -494,7 +511,7 @@ namespace { { (*i)->clean_lookup(str, sw); for (;!sw.at_end(); sw.adv()) - add_nearmiss_w(i, sw, inf); + add(i, sw); } if (sp->affix_compress) { CheckInfo ci; memset(static_cast(&ci), 0, sizeof(ci)); @@ -505,9 +522,10 @@ namespace { char * tmp = (char *)buffer.temp_ptr(); buffer.commit_temp(); *end = '\0'; - add_nearmiss(tmp, end - tmp, 0, inf); + add(tmp, end - tmp); } - } + }; + bool Working::check_word_s(ParmString word, CheckInfo * ci) { From e2448be65c2d772e0d54f33e1f7178e9bdff10af Mon Sep 17 00:00:00 2001 From: Kevin Atkinson Date: Mon, 26 Aug 2019 06:10:11 -0400 Subject: [PATCH 3/4] Checkpoint. A bit of a mess. Trying to make suggestions for run-together work better, needs more work. I don't think it will even compile. Oh yeah, add check for C++11 support, I needed it. --- configure.ac | 13 +++ modules/speller/default/suggest.cpp | 137 ++++++++++++++++++++++++---- 2 files changed, 131 insertions(+), 19 deletions(-) diff --git a/configure.ac b/configure.ac index e83afd8e..3070fa88 100644 --- a/configure.ac +++ b/configure.ac @@ -584,6 +584,19 @@ AC_TRY_COMPILE( ] ) +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # +# C++11 # +# # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + +AC_ARG_ENABLE(c++11, [ --disable-c++11]) + +if test "$disable_regex" != "no" +then + AX_CXX_COMPILE_STDCXX(11,,optional) +fi + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # Output # diff --git a/modules/speller/default/suggest.cpp b/modules/speller/default/suggest.cpp index 44cbc2f0..ee3496b9 100644 --- a/modules/speller/default/suggest.cpp +++ b/modules/speller/default/suggest.cpp @@ -241,9 +241,13 @@ namespace { }; MutableString form_word(CheckInfo & ci); - template - void try_word_n(ParmString str, Adder &); - struct PassthroughAdder; + template void try_word_n(ParmString str, Adder &); +#ifdef HAVE_CXX11 + template void try_word_s(char * word, char * word_end, Adder &&); +#endif + struct DirectAdder; + Vector try_word_c(char * word, char * word_end, unsigned pos); + bool check_word_s(ParmString word, CheckInfo * ci); unsigned check_word(char * word, char * word_end, CheckInfo * ci, /* it WILL modify word */ @@ -480,21 +484,30 @@ namespace { return MutableString(tmp,wlen); } - struct Working::PassthroughAdder { + struct Working::DirectAdder { Working * wk; const ScoreInfo & si; - PassthroughAdder(Working * wk, const ScoreInfo & si) : wk(wk), si(si) {} - void operator()(char * word, unsigned word_size) - {wk->add_nearmiss(word, word_size, 0, si);} - void operator()(SpellerImpl::WS::const_iterator i, const WordEntry & w) - {wk->add_nearmiss_w(i, w, si);} + DirectAdder(Working * wk, const ScoreInfo & si) : wk(wk), si(si) {} + void operator()(CheckInfo & ci) { + wk->form_word(ci); + char * end = (char *)wk->buffer.grow_temp(1); + char * tmp = (char *)wk->buffer.temp_ptr(); + wk->buffer.commit_temp(); + *end = '\0'; + wk->add_nearmiss(tmp, end-tmp, 0, si); + } + void operator()(SpellerImpl::WS::const_iterator i, const WordEntry & w) { + wk->add_nearmiss_w(i, w, si); + } }; void Working::try_word(char * word, char * word_end, const ScoreInfo & inf) { - if (sp->unconditional_run_together_) - try_word_c(word,word_end,inf); - else { - PassthroughAdder adder(this,inf); + if (sp->unconditional_run_together_) { + //try_word_c(word,word_end,inf); + Vector res = try_word_c(word, word_end, 0); + // FIXME: Now add words + } else { + DirectAdder adder(this,inf); try_word_n(ParmString(word,word_end-word),adder); } } @@ -517,15 +530,101 @@ namespace { CheckInfo ci; memset(static_cast(&ci), 0, sizeof(ci)); bool res = lang->affix()->affix_check(LookupInfo(sp, LookupInfo::Clean), str, ci, 0); if (!res) return; - form_word(ci); - char * end = (char *)buffer.grow_temp(1); - char * tmp = (char *)buffer.temp_ptr(); - buffer.commit_temp(); - *end = '\0'; - add(tmp, end - tmp); + add(ci); } }; + +#ifdef HAVE_CXX11 + + template + struct SimpleAdder { + Adder & adder; + void operator()(char * word, unsigned word_size) { + adder(ParmString(word, word_size)); + } + void operator()(SpellerImpl::WS::const_iterator i, const WordEntry & w) { + if (w.what == WordEntry::Misspelled) + return; + adder([](ParmString(w.word, w.word_size))); + } + }; + + template + void Working::try_word_s(char * word, char * word_end, Adder && add0) + { + SimpleAdder adder{add0}; + try_word_n(ParmString(word, word_end - word), adder); + } + // struct Working::CompoundFinishAdder { + // Working & wk; + // Vector & res; + // CompoundFinishAdder(Working & wk, Vector & res) : wk(wk), res(res) {} + // void operator()(char * word, unsigned word_size, WordInfo word_info, + // const ScoreInfo & si) { + // add(word, word_size, si); + // } + // void operator()(SpellerImpl::WS::const_iterator i, const WordEntry & w, + // const ScoreInfo & si) { + // if (w.what == WordEntry::Misspelled) + // return; + // add(w.word, w.word_size, si); + // } + // private: + // void add(const char * word, unsigned word_size, const ScoreInfo & si) { + // assert(!in.empty()); + // for (Vector::iterator i = in.begin(); i != in.end(); ++i) { + // size_t sz = i->size() + word_size; + // char * w = static_cast(wk->buffer.alloc(sz+1)); + // memcpy(w, i->str(), i->size()); + // // word is expected to be null terminated + // memcpy(w + i->size(), word, word_size + 1); + // res.push_back(ParmString(w, + // } + // } + // }; + + Vector Working::try_word_c(char * word, char * word_end, unsigned pos) { + Vector res; + // check word as is + try_word_s(word, word_end, [&res](ParmString w){res.push_back(w);}); + if (pos + 1 >= sp->run_together_limit_) + return res; + for (char * i = word + sp->run_together_min_; + i <= word_end - sp->run_together_min_; + ++i) + { + char t = *i; + *i = '\0'; + bool ok = false; + try_word_s(word, i, [&ok](ParmString){ok = true;}); + *i = t; + if (!ok) continue; + Vector suffix = try_word_c(i, word_end, pos + 1); + if (suffix.empty()) continue; + *i = '\0'; + try_word_s(word, i, [&](ParmString w) { + for (auto & s : suffix) { + auto sz = (i-word) + s.size(); + auto w = static_cast(buffer.alloc(sz + 1)); + memcpy(w, word, i-word); + memcpy(w + (i-word), s.str(), s.size()+1); + res.emplace_back(w, sz); + } + }); + *i = t; + } + return res; + } + +#else + + Vector Working::try_word_c(char * word, char * word_end, unsigned pos) { + Vector res; + return res; + } + +#endif bool Working::check_word_s(ParmString word, CheckInfo * ci) { From 683864313fbc25cd4c7c075cded947dc0de82690 Mon Sep 17 00:00:00 2001 From: Kevin Atkinson Date: Tue, 27 Aug 2019 05:02:07 -0400 Subject: [PATCH 4/4] Make suggestions for run-together work better ... --- .circleci/config.yml | 3 +- common/config.cpp | 2 + configure.ac | 6 +- m4/ax_cxx_compile_stdcxx.m4 | 1025 ++++++++++++++++++++++ modules/speller/default/speller_impl.cpp | 9 + modules/speller/default/speller_impl.hpp | 1 + modules/speller/default/suggest.cpp | 167 +--- test/suggest.mk | 1 + test/suggest/mkmk | 3 +- 9 files changed, 1079 insertions(+), 138 deletions(-) create mode 100644 m4/ax_cxx_compile_stdcxx.m4 diff --git a/.circleci/config.yml b/.circleci/config.yml index a0f34b48..58439f79 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -28,7 +28,8 @@ jobs: - run: CXX=clang++-3.5 CC=clang-3.5 ./sanity-check.sh - run: CXX=clang++-4.0 CC=clang-4.0 ./sanity-check.sh - run: ./config-opt && make -C build -j2 - + - run: rm -r build + - run: ./config-opt --disable-c++11plus && make -C build -j2 build_18_04: working_directory: ~/GNUAspell/aspell diff --git a/common/config.cpp b/common/config.cpp index 72fbc724..b4628d1e 100644 --- a/common/config.cpp +++ b/common/config.cpp @@ -1438,6 +1438,8 @@ namespace acommon { N_("maximum number that can be strung together"), KEYINFO_MAY_CHANGE} , {"run-together-min", KeyInfoInt, "3", N_("minimal length of interior words"), KEYINFO_MAY_CHANGE} + , {"run-together-suggest", KeyInfoBool, "", + N_("consider run-together words when suggesting")} , {"save-repl", KeyInfoBool , "true", N_("save replacement pairs on save all")} , {"set-prefix", KeyInfoBool, "true", diff --git a/configure.ac b/configure.ac index 3070fa88..79bf6294 100644 --- a/configure.ac +++ b/configure.ac @@ -590,11 +590,11 @@ AC_TRY_COMPILE( # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # -AC_ARG_ENABLE(c++11, [ --disable-c++11]) +AC_ARG_ENABLE(c++11plus, AS_HELP_STRING([--disable-c++11plus],[disable code that uses c++11/14])) -if test "$disable_regex" != "no" +if test "$enable_c__11plus" != "no" then - AX_CXX_COMPILE_STDCXX(11,,optional) + AX_CXX_COMPILE_STDCXX(11plus,,optional) fi # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # diff --git a/m4/ax_cxx_compile_stdcxx.m4 b/m4/ax_cxx_compile_stdcxx.m4 new file mode 100644 index 00000000..c6cd109b --- /dev/null +++ b/m4/ax_cxx_compile_stdcxx.m4 @@ -0,0 +1,1025 @@ +# =========================================================================== +# https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional]) +# +# DESCRIPTION +# +# Check for baseline language coverage in the compiler for the specified +# version of the C++ standard. If necessary, add switches to CXX and +# CXXCPP to enable support. VERSION may be '11' (for the C++11 standard) +# or '14' (for the C++14 standard). +# +# The second argument, if specified, indicates whether you insist on an +# extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g. +# -std=c++11). If neither is specified, you get whatever works, with +# preference for an extended mode. +# +# The third argument, if specified 'mandatory' or if left unspecified, +# indicates that baseline support for the specified C++ standard is +# required and that the macro should error out if no mode with that +# support is found. If specified 'optional', then configuration proceeds +# regardless, after defining HAVE_CXX${VERSION} if and only if a +# supporting mode is found. +# +# LICENSE +# +# Copyright (c) 2008 Benjamin Kosnik +# Copyright (c) 2012 Zack Weinberg +# Copyright (c) 2013 Roy Stogner +# Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov +# Copyright (c) 2015 Paul Norman +# Copyright (c) 2015 Moritz Klammler +# Copyright (c) 2016, 2018 Krzesimir Nowak +# Copyright (c) 2019 Enji Cooper +# Local Modifications: +# Copyright (c) 2019 Kevin Atkinson +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 11 + +dnl This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro +dnl (serial version number 13). + +AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl + m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"], + [$1], [11plus], [ax_cxx_compile_alternatives="11 14 1y"], + [$1], [14], [ax_cxx_compile_alternatives="14 1y"], + [$1], [17], [ax_cxx_compile_alternatives="17 1z"], + [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$2], [], [], + [$2], [ext], [], + [$2], [noext], [], + [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true], + [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true], + [$3], [optional], [ax_cxx_compile_cxx$1_required=false], + [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])]) + AC_LANG_PUSH([C++])dnl + ac_success=no + + m4_if([$2], [noext], [], [dnl + if test x$ac_success = xno; then + for alternative in ${ax_cxx_compile_alternatives}; do + switch="-std=gnu++${alternative}" + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + fi]) + + m4_if([$2], [ext], [], [dnl + if test x$ac_success = xno; then + dnl HP's aCC needs +std=c++11 according to: + dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf + dnl Cray's crayCC needs "-h std=c++11" + for alternative in ${ax_cxx_compile_alternatives}; do + for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + if test x$ac_success = xyes; then + break + fi + done + fi]) + AC_LANG_POP([C++]) + if test x$ax_cxx_compile_cxx$1_required = xtrue; then + if test x$ac_success = xno; then + AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.]) + fi + fi + if test x$ac_success = xno; then + HAVE_CXX$1=0 + AC_MSG_NOTICE([No compiler with C++$1 support was found]) + else + HAVE_CXX$1=1 + AC_DEFINE(HAVE_CXX$1,1, + [define if the compiler supports basic C++$1 syntax]) + fi + AC_SUBST(HAVE_CXX$1) +]) + + +dnl Test body for checking C++11 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 +) + +dnl Test body for checking C++14 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11plus], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11plus +) + +dnl Test body for checking C++14 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 +) + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 +) + +dnl Tests for new features in C++11 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ + +// If the compiler admits that it is not ready for C++11, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201103L + +#error "This is not a C++11 compiler" + +#else + +namespace cxx11 +{ + + namespace test_static_assert + { + + template + struct check + { + static_assert(sizeof(int) <= sizeof(T), "not big enough"); + }; + + } + + namespace test_final_override + { + + struct Base + { + virtual ~Base() {} + virtual void f() {} + }; + + struct Derived : public Base + { + virtual ~Derived() override {} + virtual void f() override {} + }; + + } + + namespace test_double_right_angle_brackets + { + + template < typename T > + struct check {}; + + typedef check single_type; + typedef check> double_type; + typedef check>> triple_type; + typedef check>>> quadruple_type; + + } + + namespace test_decltype + { + + int + f() + { + int a = 1; + decltype(a) b = 2; + return a + b; + } + + } + + namespace test_type_deduction + { + + template < typename T1, typename T2 > + struct is_same + { + static const bool value = false; + }; + + template < typename T > + struct is_same + { + static const bool value = true; + }; + + template < typename T1, typename T2 > + auto + add(T1 a1, T2 a2) -> decltype(a1 + a2) + { + return a1 + a2; + } + + int + test(const int c, volatile int v) + { + static_assert(is_same::value == true, ""); + static_assert(is_same::value == false, ""); + static_assert(is_same::value == false, ""); + auto ac = c; + auto av = v; + auto sumi = ac + av + 'x'; + auto sumf = ac + av + 1.0; + static_assert(is_same::value == true, ""); + static_assert(is_same::value == true, ""); + static_assert(is_same::value == true, ""); + static_assert(is_same::value == false, ""); + static_assert(is_same::value == true, ""); + return (sumf > 0.0) ? sumi : add(c, v); + } + + } + + namespace test_noexcept + { + + int f() { return 0; } + int g() noexcept { return 0; } + + static_assert(noexcept(f()) == false, ""); + static_assert(noexcept(g()) == true, ""); + + } + + namespace test_constexpr + { + + template < typename CharT > + unsigned long constexpr + strlen_c_r(const CharT *const s, const unsigned long acc) noexcept + { + return *s ? strlen_c_r(s + 1, acc + 1) : acc; + } + + template < typename CharT > + unsigned long constexpr + strlen_c(const CharT *const s) noexcept + { + return strlen_c_r(s, 0UL); + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("1") == 1UL, ""); + static_assert(strlen_c("example") == 7UL, ""); + static_assert(strlen_c("another\0example") == 7UL, ""); + + } + + namespace test_rvalue_references + { + + template < int N > + struct answer + { + static constexpr int value = N; + }; + + answer<1> f(int&) { return answer<1>(); } + answer<2> f(const int&) { return answer<2>(); } + answer<3> f(int&&) { return answer<3>(); } + + void + test() + { + int i = 0; + const int c = 0; + static_assert(decltype(f(i))::value == 1, ""); + static_assert(decltype(f(c))::value == 2, ""); + static_assert(decltype(f(0))::value == 3, ""); + } + + } + + namespace test_uniform_initialization + { + + struct test + { + static const int zero {}; + static const int one {1}; + }; + + static_assert(test::zero == 0, ""); + static_assert(test::one == 1, ""); + + } + + namespace test_lambdas + { + + void + test1() + { + auto lambda1 = [](){}; + auto lambda2 = lambda1; + lambda1(); + lambda2(); + } + + int + test2() + { + auto a = [](int i, int j){ return i + j; }(1, 2); + auto b = []() -> int { return '0'; }(); + auto c = [=](){ return a + b; }(); + auto d = [&](){ return c; }(); + auto e = [a, &b](int x) mutable { + const auto identity = [](int y){ return y; }; + for (auto i = 0; i < a; ++i) + a += b--; + return x + identity(a + b); + }(0); + return a + b + c + d + e; + } + + int + test3() + { + const auto nullary = [](){ return 0; }; + const auto unary = [](int x){ return x; }; + using nullary_t = decltype(nullary); + using unary_t = decltype(unary); + const auto higher1st = [](nullary_t f){ return f(); }; + const auto higher2nd = [unary](nullary_t f1){ + return [unary, f1](unary_t f2){ return f2(unary(f1())); }; + }; + return higher1st(nullary) + higher2nd(nullary)(unary); + } + + } + + namespace test_variadic_templates + { + + template + struct sum; + + template + struct sum + { + static constexpr auto value = N0 + sum::value; + }; + + template <> + struct sum<> + { + static constexpr auto value = 0; + }; + + static_assert(sum<>::value == 0, ""); + static_assert(sum<1>::value == 1, ""); + static_assert(sum<23>::value == 23, ""); + static_assert(sum<1, 2>::value == 3, ""); + static_assert(sum<5, 5, 11>::value == 21, ""); + static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, ""); + + } + + // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae + // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function + // because of this. + namespace test_template_alias_sfinae + { + + struct foo {}; + + template + using member = typename T::member_type; + + template + void func(...) {} + + template + void func(member*) {} + + void test(); + + void test() { func(0); } + + } + +} // namespace cxx11 + +#endif // __cplusplus >= 201103L + +]]) + + +dnl Tests for needed features in C++14 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11plus], [[ + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#else + +namespace cxx14 +{ + + namespace test_polymorphic_lambdas + { + + int + test() + { + const auto lambda = [](auto&&... args){ + const auto istiny = [](auto x){ + return (sizeof(x) == 1UL) ? 1 : 0; + }; + const int aretiny[] = { istiny(args)... }; + return aretiny[0]; + }; + return lambda(1, 1L, 1.0f, '1'); + } + + } + + namespace test_return_type_deduction + { + + auto f(int& x) { return x; } + decltype(auto) g(int& x) { return x; } + + template < typename T1, typename T2 > + struct is_same + { + static constexpr auto value = false; + }; + + template < typename T > + struct is_same + { + static constexpr auto value = true; + }; + + int + test() + { + auto x = 0; + static_assert(is_same::value, ""); + static_assert(is_same::value, ""); + return x; + } + + } + +} // namespace cxx14 + +#endif + +]]) + +dnl Tests for new features in C++14 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[ + +// If the compiler admits that it is not ready for C++14, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201402L + +#error "This is not a C++14 compiler" + +#else + +namespace cxx14 +{ + + namespace test_polymorphic_lambdas + { + + int + test() + { + const auto lambda = [](auto&&... args){ + const auto istiny = [](auto x){ + return (sizeof(x) == 1UL) ? 1 : 0; + }; + const int aretiny[] = { istiny(args)... }; + return aretiny[0]; + }; + return lambda(1, 1L, 1.0f, '1'); + } + + } + + namespace test_binary_literals + { + + constexpr auto ivii = 0b0000000000101010; + static_assert(ivii == 42, "wrong value"); + + } + + namespace test_generalized_constexpr + { + + template < typename CharT > + constexpr unsigned long + strlen_c(const CharT *const s) noexcept + { + auto length = 0UL; + for (auto p = s; *p; ++p) + ++length; + return length; + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("x") == 1UL, ""); + static_assert(strlen_c("test") == 4UL, ""); + static_assert(strlen_c("another\0test") == 7UL, ""); + + } + + namespace test_lambda_init_capture + { + + int + test() + { + auto x = 0; + const auto lambda1 = [a = x](int b){ return a + b; }; + const auto lambda2 = [a = lambda1(x)](){ return a; }; + return lambda2(); + } + + } + + namespace test_digit_separators + { + + constexpr auto ten_million = 100'000'000; + static_assert(ten_million == 100000000, ""); + + } + + namespace test_return_type_deduction + { + + auto f(int& x) { return x; } + decltype(auto) g(int& x) { return x; } + + template < typename T1, typename T2 > + struct is_same + { + static constexpr auto value = false; + }; + + template < typename T > + struct is_same + { + static constexpr auto value = true; + }; + + int + test() + { + auto x = 0; + static_assert(is_same::value, ""); + static_assert(is_same::value, ""); + return x; + } + + } + +} // namespace cxx14 + +#endif // __cplusplus >= 201402L + +]]) + +dnl Tests for new features in C++17 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[ + +// If the compiler admits that it is not ready for C++17, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201703L + +#error "This is not a C++17 compiler" + +#else + +#include +#include +#include + +namespace cxx17 +{ + + namespace test_constexpr_lambdas + { + + constexpr int foo = [](){return 42;}(); + + } + + namespace test::nested_namespace::definitions + { + + } + + namespace test_fold_expression + { + + template + int multiply(Args... args) + { + return (args * ... * 1); + } + + template + bool all(Args... args) + { + return (args && ...); + } + + } + + namespace test_extended_static_assert + { + + static_assert (true); + + } + + namespace test_auto_brace_init_list + { + + auto foo = {5}; + auto bar {5}; + + static_assert(std::is_same, decltype(foo)>::value); + static_assert(std::is_same::value); + } + + namespace test_typename_in_template_template_parameter + { + + template typename X> struct D; + + } + + namespace test_fallthrough_nodiscard_maybe_unused_attributes + { + + int f1() + { + return 42; + } + + [[nodiscard]] int f2() + { + [[maybe_unused]] auto unused = f1(); + + switch (f1()) + { + case 17: + f1(); + [[fallthrough]]; + case 42: + f1(); + } + return f1(); + } + + } + + namespace test_extended_aggregate_initialization + { + + struct base1 + { + int b1, b2 = 42; + }; + + struct base2 + { + base2() { + b3 = 42; + } + int b3; + }; + + struct derived : base1, base2 + { + int d; + }; + + derived d1 {{1, 2}, {}, 4}; // full initialization + derived d2 {{}, {}, 4}; // value-initialized bases + + } + + namespace test_general_range_based_for_loop + { + + struct iter + { + int i; + + int& operator* () + { + return i; + } + + const int& operator* () const + { + return i; + } + + iter& operator++() + { + ++i; + return *this; + } + }; + + struct sentinel + { + int i; + }; + + bool operator== (const iter& i, const sentinel& s) + { + return i.i == s.i; + } + + bool operator!= (const iter& i, const sentinel& s) + { + return !(i == s); + } + + struct range + { + iter begin() const + { + return {0}; + } + + sentinel end() const + { + return {5}; + } + }; + + void f() + { + range r {}; + + for (auto i : r) + { + [[maybe_unused]] auto v = i; + } + } + + } + + namespace test_lambda_capture_asterisk_this_by_value + { + + struct t + { + int i; + int foo() + { + return [*this]() + { + return i; + }(); + } + }; + + } + + namespace test_enum_class_construction + { + + enum class byte : unsigned char + {}; + + byte foo {42}; + + } + + namespace test_constexpr_if + { + + template + int f () + { + if constexpr(cond) + { + return 13; + } + else + { + return 42; + } + } + + } + + namespace test_selection_statement_with_initializer + { + + int f() + { + return 13; + } + + int f2() + { + if (auto i = f(); i > 0) + { + return 3; + } + + switch (auto i = f(); i + 4) + { + case 17: + return 2; + + default: + return 1; + } + } + + } + + namespace test_template_argument_deduction_for_class_templates + { + + template + struct pair + { + pair (T1 p1, T2 p2) + : m1 {p1}, + m2 {p2} + {} + + T1 m1; + T2 m2; + }; + + void f() + { + [[maybe_unused]] auto p = pair{13, 42u}; + } + + } + + namespace test_non_type_auto_template_parameters + { + + template + struct B + {}; + + B<5> b1; + B<'a'> b2; + + } + + namespace test_structured_bindings + { + + int arr[2] = { 1, 2 }; + std::pair pr = { 1, 2 }; + + auto f1() -> int(&)[2] + { + return arr; + } + + auto f2() -> std::pair& + { + return pr; + } + + struct S + { + int x1 : 2; + volatile double y1; + }; + + S f3() + { + return {}; + } + + auto [ x1, y1 ] = f1(); + auto& [ xr1, yr1 ] = f1(); + auto [ x2, y2 ] = f2(); + auto& [ xr2, yr2 ] = f2(); + const auto [ x3, y3 ] = f3(); + + } + + namespace test_exception_spec_type_system + { + + struct Good {}; + struct Bad {}; + + void g1() noexcept; + void g2(); + + template + Bad + f(T*, T*); + + template + Good + f(T1*, T2*); + + static_assert (std::is_same_v); + + } + + namespace test_inline_variables + { + + template void f(T) + {} + + template inline T g(T) + { + return T{}; + } + + template<> inline void f<>(int) + {} + + template<> int g<>(int) + { + return 5; + } + + } + +} // namespace cxx17 + +#endif // __cplusplus < 201703L + +]]) diff --git a/modules/speller/default/speller_impl.cpp b/modules/speller/default/speller_impl.cpp index f0704e8a..ff9efb41 100644 --- a/modules/speller/default/speller_impl.cpp +++ b/modules/speller/default/speller_impl.cpp @@ -392,6 +392,10 @@ namespace aspeller { m->run_together = m->unconditional_run_together_; return no_err; } + static PosibErr run_together_suggest(SpellerImpl * m, bool value) { + m->run_together_suggest_ = value; + return no_err; + } static PosibErr run_together_limit(SpellerImpl * m, int value) { if (value > 8) { m->config()->replace("run-together-limit", "8"); @@ -419,6 +423,9 @@ namespace aspeller { ,{"run-together", UpdateMember::Bool, UpdateMember::CN::run_together} + ,{"run-together-suggest", + UpdateMember::Bool, + UpdateMember::CN::run_together_suggest} ,{"run-together-limit", UpdateMember::Int, UpdateMember::CN::run_together_limit} @@ -554,6 +561,8 @@ namespace aspeller { unconditional_run_together_ = config_->retrieve_bool("run-together"); run_together = unconditional_run_together_; + + run_together_suggest_ = config_->retrieve_bool("run-together-suggest"); run_together_limit_ = config_->retrieve_int("run-together-limit"); if (run_together_limit_ > 8) { diff --git a/modules/speller/default/speller_impl.hpp b/modules/speller/default/speller_impl.hpp index f87b8496..ca5c3e05 100644 --- a/modules/speller/default/speller_impl.hpp +++ b/modules/speller/default/speller_impl.hpp @@ -205,6 +205,7 @@ namespace aspeller { WS check_ws, affix_ws, suggest_ws, suggest_affix_ws; bool unconditional_run_together_; + bool run_together_suggest_; unsigned int run_together_limit_; unsigned int run_together_min_; diff --git a/modules/speller/default/suggest.cpp b/modules/speller/default/suggest.cpp index ee3496b9..1effe5f3 100644 --- a/modules/speller/default/suggest.cpp +++ b/modules/speller/default/suggest.cpp @@ -242,18 +242,12 @@ namespace { MutableString form_word(CheckInfo & ci); template void try_word_n(ParmString str, Adder &); -#ifdef HAVE_CXX11 - template void try_word_s(char * word, char * word_end, Adder &&); -#endif struct DirectAdder; +#ifdef HAVE_CXX11plus + template struct SimpleAdder; + template void try_word_s(char * word, char * word_end, Adder &&); Vector try_word_c(char * word, char * word_end, unsigned pos); - - bool check_word_s(ParmString word, CheckInfo * ci); - unsigned check_word(char * word, char * word_end, CheckInfo * ci, - /* it WILL modify word */ - unsigned pos = 0); - void try_word_c(char * word, char * word_end, const ScoreInfo & inf); - +#endif void try_word(char * word, char * word_end, const ScoreInfo & inf); void try_word(char * word, char * word_end, int score) { ScoreInfo inf; @@ -468,9 +462,6 @@ namespace { } // Forms a word by combining CheckInfo fields. - // Will grow the grow the temp in the buffer. The final - // word must be null terminated and committed. - // It returns a MutableString of what was appended to the buffer. MutableString Working::form_word(CheckInfo & ci) { size_t slen = ci.word.size() - ci.pre_strip_len - ci.suf_strip_len; @@ -481,6 +472,10 @@ namespace { memcpy(tmp + ci.pre_add_len, ci.word.str() + ci.pre_strip_len, slen); if (ci.suf_add_len) memcpy(tmp + ci.pre_add_len + slen, ci.suf_add, ci.suf_add_len); + char * end = (char *)buffer.grow_temp(1); + tmp = (char *)buffer.temp_ptr(); + buffer.commit_temp(); + *end = '\0'; return MutableString(tmp,wlen); } @@ -489,12 +484,8 @@ namespace { const ScoreInfo & si; DirectAdder(Working * wk, const ScoreInfo & si) : wk(wk), si(si) {} void operator()(CheckInfo & ci) { - wk->form_word(ci); - char * end = (char *)wk->buffer.grow_temp(1); - char * tmp = (char *)wk->buffer.temp_ptr(); - wk->buffer.commit_temp(); - *end = '\0'; - wk->add_nearmiss(tmp, end-tmp, 0, si); + MutableString word = wk->form_word(ci); + wk->add_nearmiss(word.str, word.size, 0, si); } void operator()(SpellerImpl::WS::const_iterator i, const WordEntry & w) { wk->add_nearmiss_w(i, w, si); @@ -502,11 +493,16 @@ namespace { }; void Working::try_word(char * word, char * word_end, const ScoreInfo & inf) { - if (sp->unconditional_run_together_) { - //try_word_c(word,word_end,inf); +#ifdef HAVE_CXX11plus + if (sp->run_together_suggest_) { Vector res = try_word_c(word, word_end, 0); - // FIXME: Now add words - } else { + for (auto w : res) { + auto str = buffer.dup(w); + add_nearmiss(str, w.size(), 0, inf); + } + } else +#endif + { DirectAdder adder(this,inf); try_word_n(ParmString(word,word_end-word),adder); } @@ -534,60 +530,38 @@ namespace { } }; -#ifdef HAVE_CXX11 +#ifdef HAVE_CXX11plus template - struct SimpleAdder { + struct Working::SimpleAdder { + Working * wk; Adder & adder; - void operator()(char * word, unsigned word_size) { - adder(ParmString(word, word_size)); + void operator()(CheckInfo & ci) { + adder([&]{ + MutableString word = wk->form_word(ci); + return ParmString(word.str, word.size); + }); } void operator()(SpellerImpl::WS::const_iterator i, const WordEntry & w) { if (w.what == WordEntry::Misspelled) return; - adder([](ParmString(w.word, w.word_size))); + adder([&]{ + return ParmString(w.word, w.word_size); + }); } }; template void Working::try_word_s(char * word, char * word_end, Adder && add0) { - SimpleAdder adder{add0}; + SimpleAdder adder{this,add0}; try_word_n(ParmString(word, word_end - word), adder); } - // struct Working::CompoundFinishAdder { - // Working & wk; - // Vector & res; - // CompoundFinishAdder(Working & wk, Vector & res) : wk(wk), res(res) {} - // void operator()(char * word, unsigned word_size, WordInfo word_info, - // const ScoreInfo & si) { - // add(word, word_size, si); - // } - // void operator()(SpellerImpl::WS::const_iterator i, const WordEntry & w, - // const ScoreInfo & si) { - // if (w.what == WordEntry::Misspelled) - // return; - // add(w.word, w.word_size, si); - // } - // private: - // void add(const char * word, unsigned word_size, const ScoreInfo & si) { - // assert(!in.empty()); - // for (Vector::iterator i = in.begin(); i != in.end(); ++i) { - // size_t sz = i->size() + word_size; - // char * w = static_cast(wk->buffer.alloc(sz+1)); - // memcpy(w, i->str(), i->size()); - // // word is expected to be null terminated - // memcpy(w + i->size(), word, word_size + 1); - // res.push_back(ParmString(w, - // } - // } - // }; - Vector Working::try_word_c(char * word, char * word_end, unsigned pos) { Vector res; // check word as is - try_word_s(word, word_end, [&res](ParmString w){res.push_back(w);}); + try_word_s(word, word_end, [&res](auto f){res.push_back(f());}); if (pos + 1 >= sp->run_together_limit_) return res; for (char * i = word + sp->run_together_min_; @@ -597,13 +571,14 @@ namespace { char t = *i; *i = '\0'; bool ok = false; - try_word_s(word, i, [&ok](ParmString){ok = true;}); + try_word_s(word, i, [&ok](auto){ok = true;}); *i = t; if (!ok) continue; Vector suffix = try_word_c(i, word_end, pos + 1); if (suffix.empty()) continue; *i = '\0'; - try_word_s(word, i, [&](ParmString w) { + try_word_s(word, i, [&](auto f) { + auto w = f(); for (auto & s : suffix) { auto sz = (i-word) + s.size(); auto w = static_cast(buffer.alloc(sz + 1)); @@ -617,80 +592,8 @@ namespace { return res; } -#else - - Vector Working::try_word_c(char * word, char * word_end, unsigned pos) { - Vector res; - return res; - } - #endif - bool Working::check_word_s(ParmString word, CheckInfo * ci) - { - WordEntry sw; - for (SpellerImpl::WS::const_iterator i = sp->suggest_ws.begin(); - i != sp->suggest_ws.end(); - ++i) - { - (*i)->clean_lookup(word, sw); - if (!sw.at_end()) { - ci->word = sw.word; - return true; - } - } - if (sp->affix_compress) { - return lang->affix()->affix_check(LookupInfo(sp, LookupInfo::Clean), word, *ci, 0); - } - return false; - } - - unsigned Working::check_word(char * word, char * word_end, CheckInfo * ci, - /* it WILL modify word */ - unsigned pos) - { - unsigned res = check_word_s(word, ci); - if (res) return pos + 1; - if (pos + 1 >= sp->run_together_limit_) return 0; - for (char * i = word + sp->run_together_min_; - i <= word_end - sp->run_together_min_; - ++i) - { - char t = *i; - *i = '\0'; - res = check_word_s(word, ci); - *i = t; - if (!res) continue; - res = check_word(i, word_end, ci + 1, pos + 1); - if (res) return res; - } - memset(static_cast(ci), 0, sizeof(CheckInfo)); - return 0; - } - - void Working::try_word_c(char * word, char * word_end, const ScoreInfo & inf) - { - unsigned res = check_word(word, word_end, check_info); - assert(res <= sp->run_together_limit_); - //CERR.printf(">%s\n", word); - if (!res) return; - buffer.abort_temp(); - MutableString tmp = form_word(check_info[0]); - CasePattern cp = lang->case_pattern(tmp, tmp.size); - for (unsigned i = 1; i <= res; ++i) { - char * t = form_word(check_info[i]); - if (cp == FirstUpper && lang->is_lower(t[1])) - t[0] = lang->to_lower(t[0]); - } - char * end = (char *)buffer.grow_temp(1); - char * beg = (char *)buffer.temp_ptr(); // since the original string may of moved - *end = 0; - buffer.commit_temp(); - add_nearmiss(beg, end - beg, 0, inf); - //CERR.printl(tmp); - memset(check_info, 0, sizeof(CheckInfo)*res); - } - void Working::add_nearmiss(char * word, unsigned word_size, WordInfo word_info, const ScoreInfo & inf) diff --git a/test/suggest.mk b/test/suggest.mk index bfa0bb4a..97245b4a 100644 --- a/test/suggest.mk +++ b/test/suggest.mk @@ -105,4 +105,5 @@ suggest-05-common-normal-nokbd:: prep echo "ok (suggest reg. 05-common normal nokbd)" >> test-res suggest-run-together:: prep echo 'hotdoog' | inst/bin/aspell -a --run-together --run-together-limit=2 | grep -q hotdog + echo 'hotdoggman' | inst/bin/aspell -a --run-together --run-together-limit=3 | grep -q hotdogman suggest:: suggest-00-special-ultra suggest-00-special-fast suggest-00-special-normal suggest-00-special-slow suggest-00-special-bad-spellers suggest-00-special-ultra-nokbd suggest-00-special-normal-nokbd suggest-02-orig-ultra suggest-02-orig-fast suggest-02-orig-normal suggest-02-orig-slow suggest-02-orig-bad-spellers suggest-02-orig-ultra-nokbd suggest-02-orig-normal-nokbd suggest-05-common-ultra suggest-05-common-fast suggest-05-common-normal suggest-05-common-slow suggest-05-common-ultra-nokbd suggest-05-common-normal-nokbd suggest-run-together diff --git a/test/suggest/mkmk b/test/suggest/mkmk index 9a59f8a2..dc2a99ab 100755 --- a/test/suggest/mkmk +++ b/test/suggest/mkmk @@ -33,11 +33,10 @@ suggest-$f-${mode}-nokbd:: prep print <<"---"; suggest-run-together:: prep echo 'hotdoog' | inst/bin/aspell -a --run-together --run-together-limit=2 | grep -q hotdog + echo 'hotdoggman' | inst/bin/aspell -a --run-together --run-together-limit=3 | grep -q hotdogman --- $targets .= " suggest-run-together"; $targets .= "\n"; print $targets; - -