fix for loading hunspell project

1 files changed, 0 insertions, 270 deletions

diff --git a/libs/hunspell/src/phonet.cxx b/libs/hunspell/src/phonet.cxx
deleted file mode 100644
index 69601a2872..0000000000
--- a/libs/hunspell/src/phonet.cxx
+++ /dev/null
@@ -1,270 +0,0 @@
-/*  phonetic.c - generic replacement aglogithms for phonetic transformation
-    Copyright (C) 2000 Bjoern Jacke
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License version 2.1 as published by the Free Software Foundation;
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; If not, see
-    <http://www.gnu.org/licenses/>.
-
-    Changelog:
-
-    2000-01-05  Bjoern Jacke <bjoern at j3e.de>
-                Initial Release insprired by the article about phonetic
-                transformations out of c't 25/1999
-
-    2007-07-26  Bjoern Jacke <bjoern at j3e.de>
-                Released under MPL/GPL/LGPL tri-license for Hunspell
-
-    2007-08-23  Laszlo Nemeth <nemeth at OOo>
-                Porting from Aspell to Hunspell using C-like structs
-*/
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-
-#include "csutil.hxx"
-#include "phonet.hxx"
-
-void init_phonet_hash(phonetable& parms) {
-  for (int i = 0; i < HASHSIZE; i++) {
-    parms.hash[i] = -1;
-  }
-
-  for (int i = 0; parms.rules[i][0] != '\0'; i += 2) {
-    /**  set hash value  **/
-    int k = (unsigned char)parms.rules[i][0];
-
-    if (parms.hash[k] < 0) {
-      parms.hash[k] = i;
-    }
-  }
-}
-
-// like strcpy but safe if the strings overlap
-//   but only if dest < src
-static inline void strmove(char* dest, char* src) {
-  while (*src)
-    *dest++ = *src++;
-  *dest = '\0';
-}
-
-static int myisalpha(char ch) {
-  if ((unsigned char)ch < 128)
-    return isalpha(ch);
-  return 1;
-}
-
-/*  Do phonetic transformation.                        */
-/*  phonetic transcription algorithm                   */
-/*  see: http://aspell.net/man-html/Phonetic-Code.html */
-/*  convert string to uppercase before this call       */
-std::string phonet(const std::string& inword, phonetable& parms) {
-
-  int i, k = 0, p, z;
-  int k0, n0, p0 = -333;
-  char c;
-  typedef unsigned char uchar;
-
-  size_t len = inword.size();
-  if (len > MAXPHONETUTF8LEN)
-    return std::string();
-  char word[MAXPHONETUTF8LEN + 1];
-  strncpy(word, inword.c_str(), MAXPHONETUTF8LEN);
-  word[MAXPHONETUTF8LEN] = '\0';
-
-  std::string target;
-  /**  check word  **/
-  i = z = 0;
-  while ((c = word[i]) != '\0') {
-    int n = parms.hash[(uchar)c];
-    int z0 = 0;
-
-    if (n >= 0 && !parms.rules[n].empty()) {
-      /**  check all rules for the same letter  **/
-      while (parms.rules[n][0] == c) {
-        /**  check whole string  **/
-        k = 1; /** number of found letters  **/
-        p = 5; /** default priority  **/
-        const char*s = parms.rules[n].c_str();
-        s++; /**  important for (see below)  "*(s-1)"  **/
-
-        while (*s != '\0' && word[i + k] == *s && !isdigit((unsigned char)*s) &&
-               strchr("(-<^$", *s) == NULL) {
-          k++;
-          s++;
-        }
-        if (*s == '(') {
-          /**  check letters in "(..)"  **/
-          if (myisalpha(word[i + k])  // ...could be implied?
-              && strchr(s + 1, word[i + k]) != NULL) {
-            k++;
-            while (*s != ')')
-              s++;
-            s++;
-          }
-        }
-        p0 = (int)*s;
-        k0 = k;
-        while (*s == '-' && k > 1) {
-          k--;
-          s++;
-        }
-        if (*s == '<')
-          s++;
-        if (isdigit((unsigned char)*s)) {
-          /**  determine priority  **/
-          p = *s - '0';
-          s++;
-        }
-        if (*s == '^' && *(s + 1) == '^')
-          s++;
-
-        if (*s == '\0' || (*s == '^' && (i == 0 || !myisalpha(word[i - 1])) &&
-                           (*(s + 1) != '$' || (!myisalpha(word[i + k0])))) ||
-            (*s == '$' && i > 0 && myisalpha(word[i - 1]) &&
-             (!myisalpha(word[i + k0])))) {
-          /**  search for followup rules, if:     **/
-          /**  parms.followup and k > 1  and  NO '-' in searchstring **/
-          char c0 = word[i + k - 1];
-          n0 = parms.hash[(uchar)c0];
-
-          //            if (parms.followup  &&  k > 1  &&  n0 >= 0
-          if (k > 1 && n0 >= 0 && p0 != (int)'-' && word[i + k] != '\0' && !parms.rules[n0].empty()) {
-            /**  test follow-up rule for "word[i+k]"  **/
-            while (parms.rules[n0][0] == c0) {
-              /**  check whole string  **/
-              k0 = k;
-              p0 = 5;
-              s = parms.rules[n0].c_str();
-              s++;
-              while (*s != '\0' && word[i + k0] == *s &&
-                     !isdigit((unsigned char)*s) &&
-                     strchr("(-<^$", *s) == NULL) {
-                k0++;
-                s++;
-              }
-              if (*s == '(') {
-                /**  check letters  **/
-                if (myisalpha(word[i + k0]) &&
-                    strchr(s + 1, word[i + k0]) != NULL) {
-                  k0++;
-                  while (*s != ')' && *s != '\0')
-                    s++;
-                  if (*s == ')')
-                    s++;
-                }
-              }
-              while (*s == '-') {
-                /**  "k0" gets NOT reduced   **/
-                /**  because "if (k0 == k)"  **/
-                s++;
-              }
-              if (*s == '<')
-                s++;
-              if (isdigit((unsigned char)*s)) {
-                p0 = *s - '0';
-                s++;
-              }
-
-              if (*s == '\0'
-                  /**  *s == '^' cuts  **/
-                  || (*s == '$' && !myisalpha(word[i + k0]))) {
-                if (k0 == k) {
-                  /**  this is just a piece of the string  **/
-                  n0 += 2;
-                  continue;
-                }
-
-                if (p0 < p) {
-                  /**  priority too low  **/
-                  n0 += 2;
-                  continue;
-                }
-                /**  rule fits; stop search  **/
-                break;
-              }
-              n0 += 2;
-            } /**  End of "while (parms.rules[n0][0] == c0)"  **/
-
-            if (p0 >= p && parms.rules[n0][0] == c0) {
-              n += 2;
-              continue;
-            }
-          } /** end of follow-up stuff **/
-
-          /**  replace string  **/
-          s = parms.rules[n + 1].c_str();
-          p0 = (!parms.rules[n].empty() &&
-                strchr(parms.rules[n].c_str() + 1, '<') != NULL)
-                   ? 1
-                   : 0;
-          if (p0 == 1 && z == 0) {
-            /**  rule with '<' is used  **/
-            if (!target.empty() && *s != '\0' &&
-                (target[target.size()-1] == c || target[target.size()-1] == *s)) {
-              target.erase(target.size() - 1);
-            }
-            z0 = 1;
-            z = 1;
-            k0 = 0;
-            while (*s != '\0' && word[i + k0] != '\0') {
-              word[i + k0] = *s;
-              k0++;
-              s++;
-            }
-            if (k > k0)
-              strmove(&word[0] + i + k0, &word[0] + i + k);
-
-            /**  new "actual letter"  **/
-            c = word[i];
-          } else { /** no '<' rule used **/
-            i += k - 1;
-            z = 0;
-            while (*s != '\0' && *(s + 1) != '\0' && target.size() < len) {
-              if (target.empty() || target[target.size()-1] != *s) {
-                target.push_back(*s);
-              }
-              s++;
-            }
-            /**  new "actual letter"  **/
-            c = *s;
-            if (!parms.rules[n].empty() &&
-                strstr(parms.rules[n].c_str() + 1, "^^") != NULL) {
-              if (c != '\0') {
-                target.push_back(c);
-              }
-              strmove(&word[0], &word[0] + i + 1);
-              i = 0;
-              z0 = 1;
-            }
-          }
-          break;
-        } /** end of follow-up stuff **/
-        n += 2;
-      } /**  end of while (parms.rules[n][0] == c)  **/
-    }   /**  end of if (n >= 0)  **/
-    if (z0 == 0) {
-      if (k && !p0 && target.size() < len && c != '\0') {
-        /**  condense only double letters  **/
-        target.push_back(c);
-        /// printf("\n setting \n");
-      }
-
-      i++;
-      z = 0;
-      k = 0;
-    }
-  } /**  end of   while ((c = word[i]) != '\0')  **/
-
-  return target;
-} /**  end of function "phonet"  **/