Convert sources to CR+LF

1 files changed, 270 insertions, 270 deletions

diff --git a/libs/hunspell/src/phonet.c++ b/libs/hunspell/src/phonet.c++
index 69601a2872..c81d890a21 100644
--- a/libs/hunspell/src/phonet.c++
+++ b/libs/hunspell/src/phonet.c++
@@ -1,270 +1,270 @@
-/*  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"  **/
+/*  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"  **/