FinFlect: src/ffpriv_single_letter.c Source File

00001 /*
00002  * finflect - Algorithms and tools for inflecting Finnish nouns
00003  * Copyright (C) 2004, 2005  The FinFlect Team
00004  *
00005  * This library is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU Lesser General Public
00007  * License as published by the Free Software Foundation; either
00008  * version 2.1 of the License, or (at your option) any later version.
00009  *
00010  * This library is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013  * Lesser General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU Lesser General Public
00016  * License along with this library; if not, write to the Free Software
00017  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00018  *
00019  *
00020  * For the complete legal text of the GNU Lesser General Public License,
00021  * see the file LICENSE. For a complete list of authors and copyright
00022  * holders, see the file AUTHORS.
00023  */
00024 
00025 /**
00026  * @file ffpriv_ss_abnormal.c Contains the exception list for words that end in söörör
00027  * and behave abnormally, and implements the functions for getting information
00028  * from it with binary search. The functions are declared in ffpriv_ss_abnormal.h.
00029  */
00030 
00031 #include "ffpriv_single_letter.h"
00032 #include "ffstring.h"
00033 
00034 ffint32 ffpriv_single_letter(ffword* word, ffcase thecase, ffint32 count) {
00035   if ( word->data.len == 1) {
00036     ffchar c = word->data.str[0];
00037     switch(thecase) {
00038     case FFCASE_NOMINATIVE:
00039       if (count == 1) {
00040         return 0;
00041       } else {
00042         return ffstring_append(&word->data, ":t");
00043       }
00044       break;
00045     case FFCASE_GENITIVE:
00046       if (count == 1) {
00047         return ffstring_append(&word->data, ":n");
00048       } else {
00049           switch(c) {
00050             case 'f':
00051             case 'F':
00052             case 'l':
00053             case 'L':
00054             case 'm':
00055             case 'M':
00056             case 'n':
00057             case 'N':
00058             case 'r':
00059             case 'R':
00060             case 's':
00061             case 'S':
00062             case 'x':
00063             case 'X':
00064             return ffstring_append(&word->data, ":ien");
00065             break;
00066             case 'z':
00067             case 'Z':
00068             return ffstring_append(&word->data, ":jen");
00069             break;
00070           }
00071           return ffstring_append(&word->data, ":iden");
00072       }
00073       break;
00074     case FFCASE_PARTITIVE:
00075       if (count == 1) {
00076         if (ffpriv_is_back_letter(c)) {
00077           return ffstring_append(&word->data, ":ta");
00078         } else {
00079           switch(c) {
00080             case 'f':
00081             case 'F':
00082             case 'l':
00083             case 'L':
00084             case 'm':
00085             case 'M':
00086             case 'n':
00087             case 'N':
00088             case 'r':
00089             case 'R':
00090             case 's':
00091             case 'S':
00092             case 'x':
00093             case 'X':
00094             return ffstring_append(&word->data, ":ää");
00095             break;
00096           }
00097           return ffstring_append(&word->data, ":tä");
00098         }
00099       } else {
00100         if (ffpriv_is_back_letter(c)) {
00101           return ffstring_append(&word->data, ":ita");
00102         } else {
00103           switch(c) {
00104             case 'f':
00105             case 'F':
00106             case 'l':
00107             case 'L':
00108             case 'm':
00109             case 'M':
00110             case 'n':
00111             case 'N':
00112             case 'r':
00113             case 'R':
00114             case 's':
00115             case 'S':
00116             case 'x':
00117             case 'X':
00118             return ffstring_append(&word->data, ":iä");
00119             break;
00120           }
00121           return ffstring_append(&word->data, ":itä");
00122         }
00123       }
00124       break;
00125     case FFCASE_ESSIVE:
00126       if (count == 1) {
00127         if (ffpriv_is_back_letter(c)) {
00128           return ffstring_append(&word->data, ":na");
00129         } else {
00130           return ffstring_append(&word->data, ":nä");
00131         }
00132       } else {
00133         if (ffpriv_is_back_letter(c)) {
00134           return ffstring_append(&word->data, ":ina");
00135         } else {
00136           return ffstring_append(&word->data, ":inä");
00137         }
00138       }
00139       break;
00140     case FFCASE_TRANSLATIVE:
00141       if (count == 1) {
00142         return ffstring_append(&word->data, ":ksi");
00143       } else {
00144         return ffstring_append(&word->data, ":iksi");
00145       }
00146       break;
00147     case FFCASE_INESSIVE:
00148       if (count == 1) {
00149         if (ffpriv_is_back_letter(c)) {
00150           return ffstring_append(&word->data, ":ssa");
00151         } else {
00152           return ffstring_append(&word->data, ":ssä");
00153         }
00154       } else {
00155         if (ffpriv_is_back_letter(c)) {
00156           return ffstring_append(&word->data, ":issa");
00157         } else {
00158           return ffstring_append(&word->data, ":issä");
00159         }
00160       }
00161       break;
00162     case FFCASE_ELATIVE:
00163       if (count == 1) {
00164         if (ffpriv_is_back_letter(c)) {
00165           return ffstring_append(&word->data, ":sta");
00166         } else {
00167           return ffstring_append(&word->data, ":stä");
00168         }
00169       } else {
00170         if (ffpriv_is_back_letter(c)) {
00171           return ffstring_append(&word->data, ":ista");
00172         } else {
00173           return ffstring_append(&word->data, ":istä");
00174         }
00175       }
00176       break;
00177     case FFCASE_ILLATIVE:
00178       if (count == 1) {
00179         switch(c) {
00180             case 'f':
00181             case 'F':
00182             case 'l':
00183             case 'L':
00184             case 'm':
00185             case 'M':
00186             case 'n':
00187             case 'N':
00188             case 'r':
00189             case 'R':
00190             case 's':
00191             case 'S':
00192             case 'x':
00193             case 'X':
00194             return ffstring_append(&word->data, ":ään");
00195             break;
00196             case 'z':
00197             case 'Z':
00198             return ffstring_append(&word->data, ":aan");
00199             break;
00200             case 'a':
00201             case 'A':
00202             return ffstring_append(&word->data, ":han");
00203             break;
00204             case 'b':
00205             case 'B':
00206             case 'c':
00207             case 'C':
00208             case 'd':
00209             case 'D':
00210             case 'e':
00211             case 'E':
00212             case 'g':
00213             case 'G':
00214             case 'p':
00215             case 'P':
00216             case 't':
00217             case 'T':
00218             case 'v':
00219             case 'V':
00220             case 'w':
00221             case 'W':
00222             return ffstring_append(&word->data, ":hen");
00223             break;
00224             case 'h':
00225             case 'H':
00226             case 'k':
00227             case 'K':
00228             case 'o':
00229             case 'O':
00230             case 'å':
00231             case 'Å':
00232             return ffstring_append(&word->data, ":hon");
00233             break;
00234             case 'i':
00235             case 'I':
00236             case 'j':
00237             case 'J':
00238             return ffstring_append(&word->data, ":hin");
00239             break;
00240             case 'q':
00241             case 'Q':
00242             case 'u':
00243             case 'U':
00244             return ffstring_append(&word->data, ":hun");
00245             break;
00246             case 'y':
00247             case 'Y':
00248             return ffstring_append(&word->data, ":hyn");
00249             break;
00250             case 'ä':
00251             case 'Ä':
00252             return ffstring_append(&word->data, ":hän");
00253             break;
00254             case 'ö':
00255             case 'Ö':
00256             return ffstring_append(&word->data, ":hön");
00257             break;
00258           }
00259           return ffstring_append(&word->data, ":ään");
00260       } else {
00261         switch(c) {
00262             case 'f':
00263             case 'F':
00264             case 'l':
00265             case 'L':
00266             case 'm':
00267             case 'M':
00268             case 'n':
00269             case 'N':
00270             case 'r':
00271             case 'R':
00272             case 's':
00273             case 'S':
00274             case 'x':
00275             case 'X':
00276             return ffstring_append(&word->data, ":iin");
00277             break;
00278           }
00279           return ffstring_append(&word->data, ":hin");
00280       }
00281       break;
00282     case FFCASE_ADESSIVE:
00283       if (count == 1) {
00284         if (ffpriv_is_back_letter(c)) {
00285           return ffstring_append(&word->data, ":lla");
00286         } else {
00287           return ffstring_append(&word->data, ":llä");
00288         }
00289       } else {
00290         if (ffpriv_is_back_letter(c)) {
00291           return ffstring_append(&word->data, ":illa");
00292         } else {
00293           return ffstring_append(&word->data, ":illä");
00294         }
00295       }
00296       break;
00297     case FFCASE_ABLATIVE:
00298       if (count == 1) {
00299         if (ffpriv_is_back_letter(c)) {
00300           return ffstring_append(&word->data, ":lta");
00301         } else {
00302           return ffstring_append(&word->data, ":ltä");
00303         }
00304       } else {
00305         if (ffpriv_is_back_letter(c)) {
00306           return ffstring_append(&word->data, ":ilta");
00307         } else {
00308           return ffstring_append(&word->data, ":iltä");
00309         }
00310       }
00311       break;
00312     case FFCASE_ALLATIVE:
00313       if (count == 1) {
00314         return ffstring_append(&word->data, ":lle");
00315       } else {
00316         return ffstring_append(&word->data, ":ille");
00317       }
00318       break;
00319     case FFCASE_ABESSIVE:
00320       if (count == 1) {
00321         if (ffpriv_is_back_letter(c)) {
00322           return ffstring_append(&word->data, ":tta");
00323         } else {
00324           return ffstring_append(&word->data, ":ttä");
00325         }
00326       } else {
00327         if (ffpriv_is_back_letter(c)) {
00328           return ffstring_append(&word->data, ":itta");
00329         } else {
00330           return ffstring_append(&word->data, ":ittä");
00331         }
00332       }
00333       break;
00334     case FFCASE_INSTRUCTIVE:
00335       return ffstring_rfe(&word->data, word->data.len, "-");
00336       break;
00337     case FFCASE_COMITATIVE:
00338       return ffstring_append(&word->data, ":ne");
00339       break;
00340     default:
00341       return 0;
00342       break;
00343     }
00344   }
00345 
00346   return 0;
00347 }
00348 
00349 static const char* b_letters = "aAhHkKoOqQuUzZåÅ";
00350 static const ffuint32 b_len = 16;
00351 
00352 
00353 ffbool ffpriv_is_back_letter(const ffchar letter) {
00354   const char* i;
00355 
00356   for (i = b_letters;i < b_letters+b_len; ++i) {
00357     if (letter == *i ) {
00358       return 1;
00359     }
00360   }
00361   return 0;
00362 }