The first step towards fixing valgrind errors in the new hunspell....

third_party/hunspell128/src/hunspell/affixmgr.cxx

 #include "license.hunspell"
 #include "license.myspell"
 
 #ifndef MOZILLA_CLIENT
 #include <cstdlib>
 #include <cstring>
 #include <cctype>
 #include <cstdio>
 #else
 #include <stdlib.h>
@@ skipping 98 matching lines @@
   pfx = NULL;
 
   for (int i=0; i < SETSIZE; i++) {
      pStart[i] = NULL;
      sStart[i] = NULL;
      pFlag[i] = NULL;
      sFlag[i] = NULL;
   }
 
 #ifdef HUNSPELL_CHROME_CLIENT
-  if (parse_file()) {
+  // Define dummy parameters for parse_file() to avoid changing the parameters
+  // of parse_file(). This may make it easier to merge the changes of the
+  // original hunspell.
+  FILE* affpath = NULL;
+  const char* key = NULL;
 #else
-
   for (int j=0; j < CONTSIZE; j++) {
     contclasses[j] = 0;
   }
+#endif
 
   if (parse_file(affpath, key)) {
-#endif
      HUNSPELL_WARNING(stderr, "Failure loading aff file\n");
   }
   
   if (cpdmin == -1) cpdmin = MINCPDLEN;
 
 }
 
 
 AffixMgr::~AffixMgr() 
 {
@@ skipping 119 matching lines @@
   if (wordchars) free(wordchars);
   if (wordchars_utf16) free(wordchars_utf16);
   if (ignorechars) free(ignorechars);
   if (ignorechars_utf16) free(ignorechars_utf16);
   if (version) free(version);
   checknum=0;
 }
 
 
 // read in aff file and build up prefix and suffix entry objects 
-#ifdef HUNSPELL_CHROME_CLIENT
-int  AffixMgr::parse_file()
-#else
 int  AffixMgr::parse_file(FILE* aff_handle, const char * key)
-#endif
 {
-  char * line = new char[MAXLNLEN+1]; // io buffers
+  char * line; // io buffers
   char ft;     // affix type
 
   // open the affix file
 #ifdef HUNSPELL_CHROME_CLIENT
   // We're always UTF-8
   utf8 = 1;
 
-  hunspell::LineIterator af_iterator = bdict_reader->GetAffixLineIterator();
-  while (af_iterator.AdvanceAndCopy(line, MAXLNLEN)) {
+  // A BDICT file stores PFX and SFX lines in a special section and it provides
+  // a special line iterator for reading PFX and SFX lines.
+  // We create a FileMgr object from this iterator and parse PFX and SFX lines
+  // before parsing other lines.
+  hunspell::LineIterator affix_iterator = bdict_reader->GetAffixLineIterator();
+  FileMgr* iterator = new FileMgr(&affix_iterator);
+  if (!iterator) {
+    HUNSPELL_WARNING(stderr,
+        "error: could not create a FileMgr from an affix line iterator.\n");
+    return 1;
+  }
+
+  while (line = iterator->getline()) {
     ft = ' ';
     if (strncmp(line,"PFX",3) == 0) ft = complexprefixes ? 'S' : 'P';
     if (strncmp(line,"SFX",3) == 0) ft = complexprefixes ? 'P' : 'S';
     if (ft != ' ')
-      parse_affix(line, ft, &af_iterator);
+      parse_affix(line, ft, iterator, NULL);
   }
+  delete iterator;
 
-  hunspell::LineIterator iterator = bdict_reader->GetOtherLineIterator();
-
-  // Hack to keep us from having to change all of the calls below which take
-  // a LineIterator* instead of a FILE* afflst.
-  hunspell::LineIterator* afflst = &iterator;
-
-  while (iterator.AdvanceAndCopy(line, MAXLNLEN)) {
+  // Create a FileMgr object for reading lines except PFX and SFX lines.
+  // We don't need to change the loop below since our FileMgr emulates the
+  // original one.
+  hunspell::LineIterator other_iterator = bdict_reader->GetOtherLineIterator();
+  FileMgr * afflst = new FileMgr(&other_iterator);
+  if (!afflst) {
+    HUNSPELL_WARNING(stderr,
+        "error: could not create a FileMgr from an other line iterator.\n");
+    return 1;
+  }
 #else
   // checking flag duplication
   char dupflags[CONTSIZE];
   char dupflags_ini = 1;
 
   // first line indicator for removing byte order mark
   int firstline = 1;
 
   // open the affix file
   FileMgr * afflst = new FileMgr(affpath, key);
   if (!afflst) {
     HUNSPELL_WARNING(stderr, "error: could not open affix description file %s\n",affpath);
     return 1;
   }
+#endif
 
   // step one is to parse the affix file building up the internal
   // affix data structures
 
     // read in each line ignoring any that do not
     // start with a known line type indicator
     while ((line = afflst->getline())) {
        mychomp(line);
 
+#ifndef HUNSPELL_CHROME_CLIENT
        /* remove byte order mark */
        if (firstline) {
          firstline = 0;
          if (strncmp(line,"\xEF\xBB\xBF",3) == 0) {
             memmove(line, line+3, strlen(line+3)+1);
             HUNSPELL_WARNING(stderr, "warning: affix file begins with byte order mark: possible incompatibility with old Hunspell versions\n");
          }
        }
 #endif
        /* parse in the keyboard string */
        if (strncmp(line,"KEY",3) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_string(line, &keystring, 0)) {
-#else
           if (parse_string(line, &keystring, afflst->getlinenum())) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the try string */
        if (strncmp(line,"TRY",3) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_string(line, &trystring, 0)) {
-#else
           if (parse_string(line, &trystring, afflst->getlinenum())) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the name of the character set used by the .dict and .aff */
        if (strncmp(line,"SET",3) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_string(line, &encoding, 0)) {
-#else
           if (parse_string(line, &encoding, afflst->getlinenum())) {
              delete afflst;
-#endif
              return 1;
           }
           if (strcmp(encoding, "UTF-8") == 0) {
              utf8 = 1;
 #ifndef OPENOFFICEORG
 #ifndef MOZILLA_CLIENT
              if (initialize_utf_tbl()) return 1;
 #endif
 #endif
           }
        }
 
        /* parse COMPLEXPREFIXES for agglutinative languages with right-to-left writing system */
        if (strncmp(line,"COMPLEXPREFIXES",15) == 0)
                    complexprefixes = 1;
 
        /* parse in the flag used by the controlled compound words */
        if (strncmp(line,"COMPOUNDFLAG",12) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &compoundflag)) {
-#else
           if (parse_flag(line, &compoundflag, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by compound words */
        if (strncmp(line,"COMPOUNDBEGIN",13) == 0) {
           if (complexprefixes) {
-#ifdef HUNSPELL_CHROME_CLIENT
-            if (parse_flag(line, &compoundend)) {
-#else
             if (parse_flag(line, &compoundend, afflst)) {
               delete afflst;
-#endif
               return 1;
             }
           } else {
-#ifdef HUNSPELL_CHROME_CLIENT
-            if (parse_flag(line, &compoundbegin)) {
-#else
             if (parse_flag(line, &compoundbegin, afflst)) {
               delete afflst;
-#endif
               return 1;
             }
           }
        }
 
        /* parse in the flag used by compound words */
        if (strncmp(line,"COMPOUNDMIDDLE",14) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-            if (parse_flag(line, &compoundmiddle)) {
-#else
             if (parse_flag(line, &compoundmiddle, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
        /* parse in the flag used by compound words */
        if (strncmp(line,"COMPOUNDEND",11) == 0) {
           if (complexprefixes) {
-#ifdef HUNSPELL_CHROME_CLIENT
-            if (parse_flag(line, &compoundbegin)) {
-#else
             if (parse_flag(line, &compoundbegin, afflst)) {
               delete afflst;
-#endif
               return 1;
             }
           } else {
-#ifdef HUNSPELL_CHROME_CLIENT
-            if (parse_flag(line, &compoundend)) {
-#else
             if (parse_flag(line, &compoundend, afflst)) {
               delete afflst;
-#endif
               return 1;
             }
           }
        }
 
        /* parse in the data used by compound_check() method */
        if (strncmp(line,"COMPOUNDWORDMAX",15) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_num(line, &cpdwordmax)) {
-#else
           if (parse_num(line, &cpdwordmax, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag sign compounds in dictionary */
        if (strncmp(line,"COMPOUNDROOT",12) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &compoundroot)) {
-#else
           if (parse_flag(line, &compoundroot, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by compound_check() method */
        if (strncmp(line,"COMPOUNDPERMITFLAG",18) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &compoundpermitflag)) {
-#else
           if (parse_flag(line, &compoundpermitflag, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by compound_check() method */
        if (strncmp(line,"COMPOUNDFORBIDFLAG",18) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &compoundforbidflag)) {
-#else
           if (parse_flag(line, &compoundforbidflag, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        if (strncmp(line,"CHECKCOMPOUNDDUP",16) == 0) {
                    checkcompounddup = 1;
        }
 
        if (strncmp(line,"CHECKCOMPOUNDREP",16) == 0) {
                    checkcompoundrep = 1;
        }
 
        if (strncmp(line,"CHECKCOMPOUNDTRIPLE",19) == 0) {
                    checkcompoundtriple = 1;
        }
 
        if (strncmp(line,"SIMPLIFIEDTRIPLE",16) == 0) {
                    simplifiedtriple = 1;
        }
 
        if (strncmp(line,"CHECKCOMPOUNDCASE",17) == 0) {
                    checkcompoundcase = 1;
        }
 
        if (strncmp(line,"NOSUGGEST",9) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &nosuggest)) {
-#else
           if (parse_flag(line, &nosuggest, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by forbidden words */
        if (strncmp(line,"FORBIDDENWORD",13) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &forbiddenword)) {
-#else
           if (parse_flag(line, &forbiddenword, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by forbidden words */
        if (strncmp(line,"LEMMA_PRESENT",13) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &lemma_present)) {
-#else
           if (parse_flag(line, &lemma_present, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by circumfixes */
        if (strncmp(line,"CIRCUMFIX",9) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &circumfix)) {
-#else
           if (parse_flag(line, &circumfix, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by fogemorphemes */
        if (strncmp(line,"ONLYINCOMPOUND",14) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &onlyincompound)) {
-#else
           if (parse_flag(line, &onlyincompound, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by `needaffixs' */
        if (strncmp(line,"PSEUDOROOT",10) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &needaffix)) {
-#else
           if (parse_flag(line, &needaffix, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by `needaffixs' */
        if (strncmp(line,"NEEDAFFIX",9) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &needaffix)) {
-#else
           if (parse_flag(line, &needaffix, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the minimal length for words in compounds */
        if (strncmp(line,"COMPOUNDMIN",11) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_num(line, &cpdmin)) {
-#else
           if (parse_num(line, &cpdmin, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
           if (cpdmin < 1) cpdmin = 1;
        }
 
        /* parse in the max. words and syllables in compounds */
        if (strncmp(line,"COMPOUNDSYLLABLE",16) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_cpdsyllable(line)) {
-#else
           if (parse_cpdsyllable(line, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by compound_check() method */
        if (strncmp(line,"SYLLABLENUM",11) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_string(line, &cpdsyllablenum, 0)) {
-#else
           if (parse_string(line, &cpdsyllablenum, afflst->getlinenum())) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by the controlled compound words */
        if (strncmp(line,"CHECKNUM",8) == 0) {
            checknum=1;
        }
 
        /* parse in the extra word characters */
        if (strncmp(line,"WORDCHARS",9) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_array(line, &wordchars, &wordchars_utf16, &wordchars_utf16_len, utf8, 0)) {
-#else
           if (parse_array(line, &wordchars, &wordchars_utf16, &wordchars_utf16_len, utf8, afflst->getlinenum())) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the ignored characters (for example, Arabic optional diacretics charachters */
        if (strncmp(line,"IGNORE",6) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_array(line, &ignorechars, &ignorechars_utf16, &ignorechars_utf16_len, utf8, 0)) {
-#else
           if (parse_array(line, &ignorechars, &ignorechars_utf16, &ignorechars_utf16_len, utf8, afflst->getlinenum())) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
 #ifndef HUNSPELL_CHROME_CLIENT
        /* parse in the typical fault correcting table */
        if (strncmp(line,"REP",3) == 0) {
           if (parse_reptable(line, afflst)) {
              delete afflst;
              return 1;
           }
        }
 #endif
 
        /* parse in the input conversion table */
        if (strncmp(line,"ICONV",5) == 0) {
           if (parse_convtable(line, afflst, &iconvtable, "ICONV")) {
-#ifndef HUNSPELL_CHROME_CLIENT
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the input conversion table */
        if (strncmp(line,"OCONV",5) == 0) {
           if (parse_convtable(line, afflst, &oconvtable, "OCONV")) {
-#ifndef HUNSPELL_CHROME_CLIENT
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the phonetic translation table */
        if (strncmp(line,"PHONE",5) == 0) {
           if (parse_phonetable(line, afflst)) {
-#ifndef HUNSPELL_CHROME_CLIENT
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the checkcompoundpattern table */
        if (strncmp(line,"CHECKCOMPOUNDPATTERN",20) == 0) {
           if (parse_checkcpdtable(line, afflst)) {
-#ifndef HUNSPELL_CHROME_CLIENT
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the defcompound table */
        if (strncmp(line,"COMPOUNDRULE",12) == 0) {
           if (parse_defcpdtable(line, afflst)) {
-#ifndef HUNSPELL_CHROME_CLIENT
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the related character map table */
        if (strncmp(line,"MAP",3) == 0) {
           if (parse_maptable(line, afflst)) {
-#ifndef HUNSPELL_CHROME_CLIENT
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the word breakpoints table */
        if (strncmp(line,"BREAK",5) == 0) {
           if (parse_breaktable(line, afflst)) {
-#ifndef HUNSPELL_CHROME_CLIENT
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the language for language specific codes */
        if (strncmp(line,"LANG",4) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_string(line, &lang, 0)) {
-#else
           if (parse_string(line, &lang, afflst->getlinenum())) {
              delete afflst;
-#endif
              return 1;
           }
           langnum = get_lang_num(lang);
        }
 
        if (strncmp(line,"VERSION",7) == 0) {
           for(line = line + 7; *line == ' ' || *line == '\t'; line++);
           version = mystrdup(line);
        }
 
        if (strncmp(line,"MAXNGRAMSUGS",12) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_num(line, &maxngramsugs)) {
-#else
           if (parse_num(line, &maxngramsugs, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        if (strncmp(line,"NOSPLITSUGS",11) == 0) {
                    nosplitsugs=1;
        }
 
        if (strncmp(line,"FULLSTRIP",9) == 0) {
                    fullstrip=1;
        }
 
        if (strncmp(line,"SUGSWITHDOTS",12) == 0) {
                    sugswithdots=1;
        }
 
        /* parse in the flag used by forbidden words */
        if (strncmp(line,"KEEPCASE",8) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &keepcase)) {
-#else
           if (parse_flag(line, &keepcase, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        /* parse in the flag used by the affix generator */
        if (strncmp(line,"SUBSTANDARD",11) == 0) {
-#ifdef HUNSPELL_CHROME_CLIENT
-          if (parse_flag(line, &substandard)) {
-#else
           if (parse_flag(line, &substandard, afflst)) {
              delete afflst;
-#endif
              return 1;
           }
        }
 
        if (strncmp(line,"CHECKSHARPS",11) == 0) {
                    checksharps=1;
        }
 
 #ifndef HUNSPELL_CHROME_CLIENT  // Chrome handled affixes above.
        /* parse this affix: P - prefix, S - suffix */
        ft = ' ';
        if (strncmp(line,"PFX",3) == 0) ft = complexprefixes ? 'S' : 'P';
        if (strncmp(line,"SFX",3) == 0) ft = complexprefixes ? 'P' : 'S';
        if (ft != ' ') {
           if (dupflags_ini) {
             memset(dupflags, 0, sizeof(dupflags));
             dupflags_ini = 0;
           }
           if (parse_affix(line, ft, afflst, dupflags)) {
              delete afflst;
              process_pfx_tree_to_list();
              process_sfx_tree_to_list();
              return 1;
           }
        }
 #endif
     }
 
-#ifndef HUNSPELL_CHROME_CLIENT
     delete afflst;
-#endif
 
     // convert affix trees to sorted list
     process_pfx_tree_to_list();
     process_sfx_tree_to_list();
 
     // now we can speed up performance greatly taking advantage of the 
     // relationship between the affixes and the idea of "subsets".
 
     // View each prefix as a potential leading subset of another and view
     // each suffix (reversed) as a potential trailing subset of another.
@@ skipping 2609 matching lines @@
   return nosplitsugs;
 }
 
 // return sugswithdots
 int AffixMgr::get_sugswithdots(void)
 {
   return sugswithdots;
 }
 
 /* parse flag */
-#ifdef HUNSPELL_CHROME_CLIENT
-int AffixMgr::parse_flag(char * line, unsigned short * out)
-#else
 int AffixMgr::parse_flag(char * line, unsigned short * out, FileMgr * af)
-#endif
 {
    char * s = NULL;
    if (*out != FLAG_NULL && !(*out >= DEFAULTFLAGS)) {
       HUNSPELL_WARNING(stderr, "error:multiple definitions of an affix file parameter\n");
       return 1;
    }
    if (parse_string(line, &s, 0)) return 1;
    *out = pHMgr->decode_flag(s);
    free(s);
    return 0;
 }
 
 /* parse num */
-#ifdef HUNSPELL_CHROME_CLIENT
-int AffixMgr::parse_num(char * line, int * out)
-#else
 int AffixMgr::parse_num(char * line, int * out, FileMgr * af)
-#endif
 {
    char * s = NULL;
    if (*out != -1) {
       HUNSPELL_WARNING(stderr, "error: multiple definitions of an affix file parameter\n");
       return 1;
    }
    if (parse_string(line, &s, 0)) return 1;
    *out = atoi(s);
    free(s);
    return 0;
 }
 
 /* parse in the max syllablecount of compound words and  */
-#ifdef HUNSPELL_CHROME_CLIENT
-int  AffixMgr::parse_cpdsyllable(char * line)
-#else
 int  AffixMgr::parse_cpdsyllable(char * line, FileMgr * af)
-#endif
 {
    char * tp = line;
    char * piece;
    int i = 0;
    int np = 0;
    w_char w[MAXWORDLEN];
    piece = mystrsep(&tp, 0);
    while (piece) {
       if (*piece != '\0') {
           switch(i) {
@@ skipping 101 matching lines @@
              HUNSPELL_WARNING(stderr, "error: line %d: table is corrupt\n", af->getlinenum());
              numrep = 0;
              return 1;
         }
    }
    return 0;
 }
 #endif
 
 /* parse in the typical fault correcting table */
-#ifdef HUNSPELL_CHROME_CLIENT
-int  AffixMgr::parse_convtable(char * line, hunspell::LineIterator* iterator, RepList ** rl, const char * keyword)
-#else
 int  AffixMgr::parse_convtable(char * line, FileMgr * af, RepList ** rl, const char * keyword)
-#endif
 {
    if (*rl) {
       HUNSPELL_WARNING(stderr, "error: multiple table definitions\n");
       return 1;
    }
    char * tp = line;
    char * piece;
    int i = 0;
    int np = 0;
    int numrl = 0;
@@ skipping 20 matching lines @@
        piece = mystrsep(&tp, 0);
    }
    if (np != 2) {
       HUNSPELL_WARNING(stderr, "error: missing data\n");
       return 1;
    } 
  
    /* now parse the num lines to read in the remainder of the table */
    char * nl = line;
    for (int j=0; j < numrl; j++) {
-#ifdef HUNSPELL_CHROME_CLIENT
-        if (!iterator->AdvanceAndCopy(nl, MAXLNLEN))
-          return 1;
-#else
         if (!(nl = af->getline())) return 1;
-#endif
         mychomp(nl);
         tp = nl;
         i = 0;
         char * pattern = NULL;
         char * pattern2 = NULL;
         piece = mystrsep(&tp, 0);
         while (piece) {
            if (*piece != '\0') {
                switch(i) {
                   case 0: {
@@ skipping 20 matching lines @@
              HUNSPELL_WARNING(stderr, "error: table is corrupt\n");
              return 1;
         }
         (*rl)->add(pattern, pattern2);
    }
    return 0;
 }
 
 
 /* parse in the typical fault correcting table */
-#ifdef HUNSPELL_CHROME_CLIENT
-int  AffixMgr::parse_phonetable(char * line, hunspell::LineIterator* iterator)
-#else
 int  AffixMgr::parse_phonetable(char * line, FileMgr * af)
-#endif
 {
    if (phone) {
       HUNSPELL_WARNING(stderr, "error: multiple table definitions\n");
       return 1;
    }
    char * tp = line;
    char * piece;
    int i = 0;
    int np = 0;
    piece = mystrsep(&tp, 0);
@@ skipping 23 matching lines @@
        piece = mystrsep(&tp, 0);
    }
    if (np != 2) {
       HUNSPELL_WARNING(stderr, "error: missing data\n");
       return 1;
    } 
  
    /* now parse the phone->num lines to read in the remainder of the table */
    char * nl = line;
    for (int j=0; j < phone->num; j++) {
-#ifdef HUNSPELL_CHROME_CLIENT
-        if (!iterator->AdvanceAndCopy(nl, MAXLNLEN))
-          return 1;
-#else
         if (!(nl = af->getline())) return 1;
-#endif
         mychomp(nl);
         tp = nl;
         i = 0;
         phone->rules[j * 2] = NULL;
         phone->rules[j * 2 + 1] = NULL;
         piece = mystrsep(&tp, 0);
         while (piece) {
            if (*piece != '\0') {
                switch(i) {
                   case 0: {
@@ skipping 18 matching lines @@
              return 1;
         }
    }
    phone->rules[phone->num * 2] = mystrdup("");
    phone->rules[phone->num * 2 + 1] = mystrdup("");
    init_phonet_hash(*phone);
    return 0;
 }
 
 /* parse in the checkcompoundpattern table */
-#if HUNSPELL_CHROME_CLIENT
-int  AffixMgr::parse_checkcpdtable(char * line, hunspell::LineIterator* iterator)
-#else
 int  AffixMgr::parse_checkcpdtable(char * line, FileMgr * af)
-#endif
 {
    if (numcheckcpd != 0) {
       HUNSPELL_WARNING(stderr, "error: multiple table definitions\n");
       return 1;
    }
    char * tp = line;
    char * piece;
    int i = 0;
    int np = 0;
    piece = mystrsep(&tp, 0);
@@ skipping 19 matching lines @@
        piece = mystrsep(&tp, 0);
    }
    if (np != 2) {
       HUNSPELL_WARNING(stderr, "error: missing data\n");
       return 1;
    }
 
    /* now parse the numcheckcpd lines to read in the remainder of the table */
    char * nl = line;
    for (int j=0; j < numcheckcpd; j++) {
-#ifdef HUNSPELL_CHROME_CLIENT
-        if (!iterator->AdvanceAndCopy(nl, MAXLNLEN))
-          return 1;
-#else
         if (!(nl = af->getline())) return 1;
-#endif
         mychomp(nl);
         tp = nl;
         i = 0;
         checkcpdtable[j].pattern = NULL;
         checkcpdtable[j].pattern2 = NULL;
         checkcpdtable[j].pattern3 = NULL;
         checkcpdtable[j].cond = FLAG_NULL;
         checkcpdtable[j].cond2 = FLAG_NULL;
         piece = mystrsep(&tp, 0);
         while (piece) {
@@ skipping 34 matching lines @@
         if ((!(checkcpdtable[j].pattern)) || (!(checkcpdtable[j].pattern2))) {
              HUNSPELL_WARNING(stderr, "error: table is corrupt\n");
              numcheckcpd = 0;
              return 1;
         }
    }
    return 0;
 }
 
 /* parse in the compound rule table */
-#ifdef HUNSPELL_CHROME_CLIENT
-int  AffixMgr::parse_defcpdtable(char * line, hunspell::LineIterator* iterator)
-#else
 int  AffixMgr::parse_defcpdtable(char * line, FileMgr * af)
-#endif
 {
    if (numdefcpd != 0) {
       HUNSPELL_WARNING(stderr, "error: multiple table definitions\n");
       return 1;
    }
    char * tp = line;
    char * piece;
    int i = 0;
    int np = 0;
    piece = mystrsep(&tp, 0);
@@ skipping 19 matching lines @@
        piece = mystrsep(&tp, 0);
    }
    if (np != 2) {
       HUNSPELL_WARNING(stderr, "error: missing data\n");
       return 1;
    } 
  
    /* now parse the numdefcpd lines to read in the remainder of the table */
    char * nl = line;
    for (int j=0; j < numdefcpd; j++) {
-#ifdef HUNSPELL_CHROME_CLIENT
-        if (!iterator->AdvanceAndCopy(nl, MAXLNLEN))
-          return 1;
-#else
         if (!(nl = af->getline())) return 1;
-#endif
         mychomp(nl);
         tp = nl;
         i = 0;
         defcpdtable[j].def = NULL;
         piece = mystrsep(&tp, 0);
         while (piece) {
            if (*piece != '\0') {
                switch(i) {
                   case 0: {
                              if (strncmp(piece, "COMPOUNDRULE", 12) != 0) {
@@ skipping 38 matching lines @@
              HUNSPELL_WARNING(stderr, "error: line table is corrupt\n");
              numdefcpd = 0;
              return 1;
         }
    }
    return 0;
 }
 
 
 /* parse in the character map table */
-#ifdef HUNSPELL_CHROME_CLIENT
-int  AffixMgr::parse_maptable(char * line, hunspell::LineIterator* iterator)
-#else
 int  AffixMgr::parse_maptable(char * line, FileMgr * af)
-#endif
 {
    if (nummap != 0) {
       HUNSPELL_WARNING(stderr, "error: multiple table definitions\n");
       return 1;
    }
    char * tp = line;
    char * piece;
    int i = 0;
    int np = 0;
    piece = mystrsep(&tp, 0);
@@ skipping 19 matching lines @@
        piece = mystrsep(&tp, 0);
    }
    if (np != 2) {
       HUNSPELL_WARNING(stderr, "error: line missing data\n");
       return 1;
    } 
  
    /* now parse the nummap lines to read in the remainder of the table */
    char * nl = line;
    for (int j=0; j < nummap; j++) {
-#ifdef HUNSPELL_CHROME_CLIENT
-        if (!iterator->AdvanceAndCopy(nl, MAXLNLEN))
-          return 1;
-#else
         if (!(nl = af->getline())) return 1;
-#endif
         mychomp(nl);
         tp = nl;
         i = 0;
         maptable[j].set = NULL;
         maptable[j].len = 0;
         piece = mystrsep(&tp, 0);
         while (piece) {
            if (*piece != '\0') {
                switch(i) {
                   case 0: {
@@ skipping 32 matching lines @@
         if ((!(maptable[j].set || maptable[j].set_utf16)) || (!(maptable[j].len))) {
              HUNSPELL_WARNING(stderr, "error: table is corrupt\n");
              nummap = 0;
              return 1;
         }
    }
    return 0;
 }
 
 /* parse in the word breakpoint table */
-#ifdef HUNSPELL_CHROME_CLIENT
-int  AffixMgr::parse_breaktable(char * line, hunspell::LineIterator* iterator)
-#else
 int  AffixMgr::parse_breaktable(char * line, FileMgr * af)
-#endif
 {
    if (numbreak != 0) {
       HUNSPELL_WARNING(stderr, "error: multiple table definitions\n");
       return 1;
    }
    char * tp = line;
    char * piece;
    int i = 0;
    int np = 0;
    piece = mystrsep(&tp, 0);
@@ skipping 19 matching lines @@
        piece = mystrsep(&tp, 0);
    }
    if (np != 2) {
       HUNSPELL_WARNING(stderr, "error: missing data\n");
       return 1;
    } 
  
    /* now parse the numbreak lines to read in the remainder of the table */
    char * nl = line;
    for (int j=0; j < numbreak; j++) {
-#ifdef HUNSPELL_CHROME_CLIENT
-        if (!iterator->AdvanceAndCopy(nl, MAXLNLEN))
-          return 1;
-#else
         if (!(nl = af->getline())) return 1;
-#endif
         mychomp(nl);
         tp = nl;
         i = 0;
         piece = mystrsep(&tp, 0);
         while (piece) {
            if (*piece != '\0') {
                switch(i) {
                   case 0: {
                              if (strncmp(piece,"BREAK",5) != 0) {
                                  HUNSPELL_WARNING(stderr, "error: table is corrupt\n");
@@ skipping 38 matching lines @@
           case '^': {
                if (*(k+1) == ']') neg = 1; else *(k+1) = *k;
                break;
                 }
           default: {
             if (neg) *(k+1) = *k;
           }
        }
     }
 }
-#ifdef HUNSPELL_CHROME_CLIENT
-int  AffixMgr::parse_affix(char * line, const char at, hunspell::LineIterator* iterator)
-#else
 int  AffixMgr::parse_affix(char * line, const char at, FileMgr * af, char * dupflags)
-#endif
 {
    int numents = 0;      // number of affentry structures to parse
 
    unsigned short aflag = 0;      // affix char identifier
 
    char ff=0;
    struct affentry * ptr= NULL;
    struct affentry * nptr= NULL;
 
    char * tp = line;
@@ skipping 71 matching lines @@
        }
        free(ptr);
        return 1;
    }
  
    // store away ptr to first affentry
    nptr = ptr;
 
    // now parse numents affentries for this affix
    for (int j=0; j < numents; j++) {
-#ifdef HUNSPELL_CHROME_CLIENT
-      if (!iterator->AdvanceAndCopy(nl, MAXLNLEN))
-        return 1;
-#else
       if (!(nl = af->getline())) return 1;
-#endif
       mychomp(nl);
       tp = nl;
       i = 0;
       np = 0;
 
       // split line into pieces
       piece = mystrsep(&tp, 0);
       while (piece) {
          if (*piece != '\0') {
              switch(i) {
@@ skipping 243 matching lines @@
             HUNSPELL_WARNING(stderr, "warning: line %d: incompatible stripping characters and condition\n", linenum);
             return 0;
           }
         }
       }
       if (j < 0) return 1;
     }
   }
   return 0;
 }