finflect.c

Go to the documentation of this file.

/*
 * finflect - Algorithms and tools for inflecting Finnish nouns
 * Copyright (C) 2004, 2005  The FinFlect Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 * For the complete legal text of the GNU Lesser General Public License,
 * see the file LICENSE. For a complete list of authors and copyright
 * holders, see the file AUTHORS.
 */

/**
 * @file finflect.c Implementations for the public API functions defined in finflect.h.
 */ 

#include <stdlib.h>
#include <string.h>
#include <strings.h>

#include "finflect.h"
#include "ffpriv_basic_cases.h"
#include "ffpriv_general_local_cases.h"
#include "ffpriv_exterior_local_cases.h"
#include "ffpriv_interior_local_cases.h"
#include "ffpriv_means_cases.h"

ffchar* ff_inflect(const ffchar* word, ffcase thecase, ffint32 count)
{
  switch(thecase) {
  case FFCASE_NOMINATIVE:
    if(count == 1)
      return ff_nominative_singular(word);
    else
      return ff_nominative_plural(word);
    break;
  case FFCASE_GENITIVE:
    if(count == 1)
      return ff_genitive_singular(word);
    else
      return ff_genitive_plural(word);
    break;
  case FFCASE_PARTITIVE:
    if(count == 1)
      return ff_partitive_singular(word);
    else
      return ff_partitive_plural(word);
    break;
  case FFCASE_ESSIVE:
    if(count == 1)
      return ff_essive_singular(word);
    else
      return ff_essive_plural(word);
    break;
  case FFCASE_TRANSLATIVE:
    if(count == 1)
      return ff_translative_singular(word);
    else
      return ff_translative_plural(word);
    break;
  case FFCASE_INESSIVE:
    if(count == 1)
      return ff_inessive_singular(word);
    else
      return ff_inessive_plural(word);
    break;
  case FFCASE_ELATIVE:
    if(count == 1)
      return ff_elative_singular(word);
    else
      return ff_elative_plural(word);
    break;
  case FFCASE_ILLATIVE:
    if(count == 1)
      return ff_illative_singular(word);
    else
      return ff_illative_plural(word);
    break;
  case FFCASE_ADESSIVE:
    if(count == 1)
      return ff_adessive_singular(word);
    else
      return ff_adessive_plural(word);
    break;
  case FFCASE_ABLATIVE:
    if(count == 1)
      return ff_ablative_singular(word);
    else
      return ff_ablative_plural(word);
    break;
  case FFCASE_ALLATIVE:
    if(count == 1)
      return ff_allative_singular(word);
    else
      return ff_allative_plural(word);
    break;
  case FFCASE_ABESSIVE:
    if(count == 1)
      return ff_abessive_singular(word);
    else
      return ff_abessive_plural(word);
    break;
  case FFCASE_INSTRUCTIVE:
    if(count == 1)
      return ff_instructive_singular(word);
    else
      return ff_instructive_plural(word);
    break;
  case FFCASE_COMITATIVE:
    if(count == 1)
      /** @todo curse user? */
      return (ffchar*)strdup("-");
    else
      return ff_comitative_plural(word);
    break;
  default:
    return NULL;
    break;
  }
}

ffchar* ff_nominative_singular(const ffchar* word)
{
  return (ffchar*)strdup(word);
}

ffchar* ff_nominative_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_nominative_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_genitive_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_genitive_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_genitive_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_genitive_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_essive_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_essive_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_essive_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_essive_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_partitive_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_partitive_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_partitive_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_partitive_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_translative_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_translative_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_translative_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_translative_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_inessive_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_inessive_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_inessive_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_inessive_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_elative_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_elative_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_elative_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_elative_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_illative_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_illative_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_illative_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_illative_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_adessive_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_adessive_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_adessive_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_adessive_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_ablative_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_ablative_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_ablative_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_ablative_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_allative_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_allative_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_allative_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_allative_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_abessive_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_abessive_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_abessive_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_abessive_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_instructive_singular(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_instructive_singular(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_instructive_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_instructive_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

ffchar* ff_comitative_plural(const ffchar* word)
{
  ffword theword;
  ffword_create(word, &theword);
  ffpriv_comitative_plural(&theword);
  ffword_finalize(&theword);
  return theword.data.str;
}

---