LCOV - app.info - extensions/spellcheck/hunspell/src/dictmgr.cpp

LCOV - code coverage report
| Current view: | directory - extensions/spellcheck/hunspell/src - dictmgr.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 96 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 7 | 0 | 0.0 %

           1                 : /******* BEGIN LICENSE BLOCK *******
           2                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           3                 :  *
           4                 :  * The contents of this file are subject to the Mozilla Public License Version
           5                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           6                 :  * the License. You may obtain a copy of the License at
           7                 :  * http://www.mozilla.org/MPL/
           8                 :  *
           9                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          10                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          11                 :  * for the specific language governing rights and limitations under the
          12                 :  * License.
          13                 :  *
          14                 :  * The Initial Developers of the Original Code are Kevin Hendricks (MySpell)
          15                 :  * and László Németh (Hunspell). Portions created by the Initial Developers
          16                 :  * are Copyright (C) 2002-2005 the Initial Developers. All Rights Reserved.
          17                 :  *
          18                 :  * Contributor(s): László Németh (nemethl@gyorsposta.hu)
          19                 :  *                 Caolan McNamara (caolanm@redhat.com)
          20                 :  *
          21                 :  * Alternatively, the contents of this file may be used under the terms of
          22                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
          23                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          24                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          25                 :  * of those above. If you wish to allow use of your version of this file only
          26                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          27                 :  * use your version of this file under the terms of the MPL, indicate your
          28                 :  * decision by deleting the provisions above and replace them with the notice
          29                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          30                 :  * the provisions above, a recipient may use your version of this file under
          31                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          32                 :  *
          33                 :  ******* END LICENSE BLOCK *******/
          34                 :
          35                 : #include <stdlib.h>
          36                 : #include <string.h>
          37                 : #include <ctype.h>
          38                 : #include <stdio.h>
          39                 :
          40                 : #include "dictmgr.hxx"
          41                 :
          42               0 : DictMgr::DictMgr(const char * dictpath, const char * etype) : numdict(0)
          43                 : {
          44                 :   // load list of etype entries
          45               0 :   pdentry = (dictentry *)malloc(MAXDICTIONARIES*sizeof(struct dictentry));
          46               0 :   if (pdentry) {
          47               0 :      if (parse_file(dictpath, etype)) {
          48               0 :         numdict = 0;
          49                 :         // no dictionary.lst found is okay
          50                 :      }
          51                 :   }
          52               0 : }
          53                 :
          54                 :
          55               0 : DictMgr::~DictMgr()
          56                 : {
          57               0 :   dictentry * pdict = NULL;
          58               0 :   if (pdentry) {
          59               0 :      pdict = pdentry;
          60               0 :      for (int i=0;i<numdict;i++) {
          61               0 :         if (pdict->lang) {
          62               0 :             free(pdict->lang);
          63               0 :             pdict->lang = NULL;
          64                 :         }
          65               0 :         if (pdict->region) {
          66               0 :             free(pdict->region);
          67               0 :             pdict->region=NULL;
          68                 :         }
          69               0 :         if (pdict->filename) {
          70               0 :             free(pdict->filename);
          71               0 :             pdict->filename = NULL;
          72                 :         }
          73               0 :         pdict++;
          74                 :      }
          75               0 :      free(pdentry);
          76               0 :      pdentry = NULL;
          77               0 :      pdict = NULL;
          78                 :   }
          79               0 :   numdict = 0;
          80               0 : }
          81                 :
          82                 :
          83                 : // read in list of etype entries and build up structure to describe them
          84               0 : int  DictMgr::parse_file(const char * dictpath, const char * etype)
          85                 : {
          86                 :
          87                 :     int i;
          88                 :     char line[MAXDICTENTRYLEN+1];
          89               0 :     dictentry * pdict = pdentry;
          90                 :
          91                 :     // open the dictionary list file
          92                 :     FILE * dictlst;
          93               0 :     dictlst = fopen(dictpath,"r");
          94               0 :     if (!dictlst) {
          95               0 :       return 1;
          96                 :     }
          97                 :
          98                 :     // step one is to parse the dictionary list building up the
          99                 :     // descriptive structures
         100                 :
         101                 :     // read in each line ignoring any that dont start with etype
         102               0 :     while (fgets(line,MAXDICTENTRYLEN,dictlst)) {
         103               0 :        mychomp(line);
         104                 :
         105                 :        /* parse in a dictionary entry */
         106               0 :        if (strncmp(line,etype,4) == 0) {
         107               0 :           if (numdict < MAXDICTIONARIES) {
         108               0 :              char * tp = line;
         109                 :              char * piece;
         110               0 :              i = 0;
         111               0 :              while ((piece=mystrsep(&tp,' '))) {
         112               0 :                 if (*piece != '\0') {
         113               0 :                     switch(i) {
         114               0 :                        case 0: break;
         115               0 :                        case 1: pdict->lang = mystrdup(piece); break;
         116               0 :                        case 2: if (strcmp (piece, "ANY") == 0)
         117               0 :                                  pdict->region = mystrdup("");
         118                 :                                else
         119               0 :                                  pdict->region = mystrdup(piece);
         120               0 :                                break;
         121               0 :                        case 3: pdict->filename = mystrdup(piece); break;
         122               0 :                        default: break;
         123                 :                     }
         124               0 :                     i++;
         125                 :                 }
         126               0 :                 free(piece);
         127                 :              }
         128               0 :              if (i == 4) {
         129               0 :                  numdict++;
         130               0 :                  pdict++;
         131                 :              } else {
         132               0 :                  switch (i) {
         133                 :                     case 3:
         134               0 :                        free(pdict->region);
         135               0 :                        pdict->region=NULL;
         136                 :                     case 2: //deliberate fallthrough
         137               0 :                        free(pdict->lang);
         138               0 :                        pdict->lang=NULL;
         139                 :                     default:
         140                 :                         break;
         141                 :                  }
         142               0 :                  fprintf(stderr,"dictionary list corruption in line \"%s\"\n",line);
         143               0 :                  fflush(stderr);
         144                 :              }
         145                 :           }
         146                 :        }
         147                 :     }
         148               0 :     fclose(dictlst);
         149               0 :     return 0;
         150                 : }
         151                 :
         152                 : // return text encoding of dictionary
         153               0 : int DictMgr::get_list(dictentry ** ppentry)
         154                 : {
         155               0 :   *ppentry = pdentry;
         156               0 :   return numdict;
         157                 : }
         158                 :
         159                 :
         160                 :
         161                 : // strip strings into token based on single char delimiter
         162                 : // acts like strsep() but only uses a delim char and not
         163                 : // a delim string
         164                 :
         165               0 : char * DictMgr::mystrsep(char ** stringp, const char delim)
         166                 : {
         167               0 :   char * rv = NULL;
         168               0 :   char * mp = *stringp;
         169               0 :   size_t n = strlen(mp);
         170               0 :   if (n > 0) {
         171               0 :      char * dp = (char *)memchr(mp,(int)((unsigned char)delim),n);
         172               0 :      if (dp) {
         173               0 :         *stringp = dp+1;
         174               0 :         size_t nc = dp - mp;
         175               0 :         rv = (char *) malloc(nc+1);
         176               0 :         if (rv) {
         177               0 :            memcpy(rv,mp,nc);
         178               0 :            *(rv+nc) = '\0';
         179                 :         }
         180                 :      } else {
         181               0 :        rv = (char *) malloc(n+1);
         182               0 :        if (rv) {
         183               0 :           memcpy(rv, mp, n);
         184               0 :           *(rv+n) = '\0';
         185               0 :           *stringp = mp + n;
         186                 :        }
         187                 :      }
         188                 :   }
         189               0 :   return rv;
         190                 : }
         191                 :
         192                 :
         193                 : // replaces strdup with ansi version
         194               0 : char * DictMgr::mystrdup(const char * s)
         195                 : {
         196               0 :   char * d = NULL;
         197               0 :   if (s) {
         198               0 :      int sl = strlen(s)+1;
         199               0 :      d = (char *) malloc(sl);
         200               0 :      if (d) memcpy(d,s,sl);
         201                 :   }
         202               0 :   return d;
         203                 : }
         204                 :
         205                 :
         206                 : // remove cross-platform text line end characters
         207               0 : void DictMgr:: mychomp(char * s)
         208                 : {
         209               0 :   int k = strlen(s);
         210               0 :   if ((k > 0) && ((*(s+k-1)=='\r') || (*(s+k-1)=='\n'))) *(s+k-1) = '\0';
         211               0 :   if ((k > 1) && (*(s+k-2) == '\r')) *(s+k-2) = '\0';
         212               0 : }
         213                 :

Generated by: LCOV version 1.7