LCOV - code coverage report
Current view: top level - src/backend/tsearch - dict_ispell.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 42 55 76.4 %
Date: 2019-11-21 12:06:29 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * dict_ispell.c
       4             :  *      Ispell dictionary interface
       5             :  *
       6             :  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
       7             :  *
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *    src/backend/tsearch/dict_ispell.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : #include "postgres.h"
      15             : 
      16             : #include "commands/defrem.h"
      17             : #include "tsearch/dicts/spell.h"
      18             : #include "tsearch/ts_locale.h"
      19             : #include "tsearch/ts_utils.h"
      20             : #include "utils/builtins.h"
      21             : 
      22             : 
      23             : typedef struct
      24             : {
      25             :     StopList    stoplist;
      26             :     IspellDict  obj;
      27             : } DictISpell;
      28             : 
      29             : Datum
      30          94 : dispell_init(PG_FUNCTION_ARGS)
      31             : {
      32          94 :     List       *dictoptions = (List *) PG_GETARG_POINTER(0);
      33             :     DictISpell *d;
      34          94 :     bool        affloaded = false,
      35          94 :                 dictloaded = false,
      36          94 :                 stoploaded = false;
      37             :     ListCell   *l;
      38             : 
      39          94 :     d = (DictISpell *) palloc0(sizeof(DictISpell));
      40             : 
      41          94 :     NIStartBuild(&(d->obj));
      42             : 
      43         274 :     foreach(l, dictoptions)
      44             :     {
      45         184 :         DefElem    *defel = (DefElem *) lfirst(l);
      46             : 
      47         184 :         if (strcmp(defel->defname, "dictfile") == 0)
      48             :         {
      49          90 :             if (dictloaded)
      50           0 :                 ereport(ERROR,
      51             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
      52             :                          errmsg("multiple DictFile parameters")));
      53          90 :             NIImportDictionary(&(d->obj),
      54          90 :                                get_tsearch_config_filename(defGetString(defel),
      55             :                                                            "dict"));
      56          90 :             dictloaded = true;
      57             :         }
      58          94 :         else if (strcmp(defel->defname, "afffile") == 0)
      59             :         {
      60          90 :             if (affloaded)
      61           0 :                 ereport(ERROR,
      62             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
      63             :                          errmsg("multiple AffFile parameters")));
      64          90 :             NIImportAffixes(&(d->obj),
      65          90 :                             get_tsearch_config_filename(defGetString(defel),
      66             :                                                         "affix"));
      67          90 :             affloaded = true;
      68             :         }
      69           4 :         else if (strcmp(defel->defname, "stopwords") == 0)
      70             :         {
      71           0 :             if (stoploaded)
      72           0 :                 ereport(ERROR,
      73             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
      74             :                          errmsg("multiple StopWords parameters")));
      75           0 :             readstoplist(defGetString(defel), &(d->stoplist), lowerstr);
      76           0 :             stoploaded = true;
      77             :         }
      78             :         else
      79             :         {
      80           4 :             ereport(ERROR,
      81             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
      82             :                      errmsg("unrecognized Ispell parameter: \"%s\"",
      83             :                             defel->defname)));
      84             :         }
      85             :     }
      86             : 
      87          90 :     if (affloaded && dictloaded)
      88             :     {
      89          90 :         NISortDictionary(&(d->obj));
      90          78 :         NISortAffixes(&(d->obj));
      91             :     }
      92           0 :     else if (!affloaded)
      93             :     {
      94           0 :         ereport(ERROR,
      95             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
      96             :                  errmsg("missing AffFile parameter")));
      97             :     }
      98             :     else
      99             :     {
     100           0 :         ereport(ERROR,
     101             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     102             :                  errmsg("missing DictFile parameter")));
     103             :     }
     104             : 
     105          78 :     NIFinishBuild(&(d->obj));
     106             : 
     107         156 :     PG_RETURN_POINTER(d);
     108             : }
     109             : 
     110             : Datum
     111         500 : dispell_lexize(PG_FUNCTION_ARGS)
     112             : {
     113         500 :     DictISpell *d = (DictISpell *) PG_GETARG_POINTER(0);
     114         500 :     char       *in = (char *) PG_GETARG_POINTER(1);
     115         500 :     int32       len = PG_GETARG_INT32(2);
     116             :     char       *txt;
     117             :     TSLexeme   *res;
     118             :     TSLexeme   *ptr,
     119             :                *cptr;
     120             : 
     121         500 :     if (len <= 0)
     122           0 :         PG_RETURN_POINTER(NULL);
     123             : 
     124         500 :     txt = lowerstr_with_len(in, len);
     125         500 :     res = NINormalizeWord(&(d->obj), txt);
     126             : 
     127         500 :     if (res == NULL)
     128          96 :         PG_RETURN_POINTER(NULL);
     129             : 
     130         404 :     cptr = res;
     131        1280 :     for (ptr = cptr; ptr->lexeme; ptr++)
     132             :     {
     133         876 :         if (searchstoplist(&(d->stoplist), ptr->lexeme))
     134             :         {
     135           0 :             pfree(ptr->lexeme);
     136           0 :             ptr->lexeme = NULL;
     137             :         }
     138             :         else
     139             :         {
     140         876 :             if (cptr != ptr)
     141           0 :                 memcpy(cptr, ptr, sizeof(TSLexeme));
     142         876 :             cptr++;
     143             :         }
     144             :     }
     145         404 :     cptr->lexeme = NULL;
     146             : 
     147         404 :     PG_RETURN_POINTER(res);
     148             : }

Generated by: LCOV version 1.13