The first step towards supporting the Hungarian spell-checking dictionary....

chrome/tools/convert_dict/aff_reader.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/tools/convert_dict/aff_reader.h"
 
 #include <algorithm>
 
 #include "base/file_util.h"
 #include "base/i18n/icu_string_conversions.h"
@@ skipping 193 matching lines @@
         size_t part_start = i;
         std::string part;
         if (token[0] != 'Y' && token[0] != 'N') {
           // This token represents a stripping prefix or suffix, which is
           // either a length or a string to be replaced.
           // We also reencode them to UTF-8.
           part_start = i - token.length();
         }
         part = rule->substr(part_start);  // From here to end.
 
+        if (part.find('-') != std::string::npos) {
+          // This rule has a morph rule used by old Hungarian dictionaries.
+          // When a line has a morph rule, its format becomes as listed below.
+          //   AFX D   0 d e - M
+          // To make hunspell work more happily, replace this morph rule with
+          // a compound flag as listed below.
+          //   AFX D   0 d/M e
+          std::vector<std::string> tokens;
+          SplitString(part, ' ', &tokens);
+          if (tokens.size() >= 5) {
+            part = StringPrintf("%s %s/%s %s",
+                                tokens[0].c_str(),
+                                tokens[1].c_str(), tokens[4].c_str(),
+                                tokens[2].c_str());
+          }
+        }
+
         size_t slash_index = part.find('/');
         if (slash_index != std::string::npos && !has_indexed_affixes()) {
           // This can also have a rule string associated with it following a
           // slash. For example:
           //    PFX P   0 foo/Y  .
           // The "Y" is a flag. For example, the aff file might have a line:
           //    COMPOUNDFLAG Y
           // so that means that this prefix would be a compound one.
           //
           // It expects these rules to use the same alias rules as the .dic
@@ skipping 62 matching lines @@
   other_commands_.push_back(line);
 }
 
 void AffReader::HandleEncodedCommand(const std::string& line) {
   std::string utf8;
   if (EncodingToUTF8(line, &utf8))
     other_commands_.push_back(utf8);
 }
 
 }  // namespace convert_dict