main.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 main.c The FinFlect demo program
 */

#include "finflect.h"
#include "ffconfig.h"

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

#define _GNU_SOURCE
#include <getopt.h>

#define MODE_NORMAL 400
#define MODE_ALL 401

#define OPT_VERSION 800
#define OPT_HELP 801
#define OPT_ALL 802
#define OPT_SINGULAR 803
#define OPT_PLURAL 804
#define OPT_COUNT 805

void print_version() {
  printf("FinFlect version %s\n", FF_VERSION);
  printf("Copyright (C) 2004, 2005  The FinFlect Team\n");
}

void print_help() {
  printf("usage: finflect [options] <word>\n\n");

  printf("general options:\n\n");

  printf("      --version        -V     Shows the version information and exits.\n");
  printf("      --help           -h     Shows this help text and exits.\n");
  printf("      --all            -a     Shows a table of all inflections and exits.\n\n");

  printf("cases:\n\n");

  printf("      --nominative            (implied unless another case is specified)\n");
  printf("      --partitive\n");
  printf("      --genitive\n");
  printf("      --essive\n");
  printf("      --translative\n");
  printf("      --inessive\n");
  printf("      --elative\n");
  printf("      --illative\n");
  printf("      --adessive\n");
  printf("      --ablative\n");
  printf("      --allative\n");
  printf("      --abessive\n");
  printf("      --comitative            NOTE: Comitative has no singular form\n\n");
  printf("      --instructive\n\n");

  printf("counts:\n\n");

  printf("      --singular              (implied unless --plural is specified)\n");
  printf("      --plural\n\n");
  printf("      --count=N               singular if N == 1, plural otherwise\n\n");
}


int main(int argc, char** argv) {
  int opt;
  ffcase thecase = FFCASE_NOMINATIVE;
  ffint32 count = FFCOUNT_SINGULAR;
  ffchar* word = NULL;
  ffint32 mode = MODE_NORMAL;

  /* Kids, don't try this at home... */
  struct option longopts[21];
  longopts[0] = (struct option) {"version", 0, NULL, OPT_VERSION
                };
  longopts[1] = (struct option) {"help", 0, NULL, OPT_HELP
                };
  longopts[2] = (struct option) {"all", 0, NULL, OPT_ALL
                };

  longopts[3] = (struct option) {"nominative", 0, NULL, FFCASE_NOMINATIVE
                };
  longopts[4] = (struct option) {"partitive", 0, NULL, FFCASE_PARTITIVE
                };
  longopts[5] = (struct option) {"genitive", 0, NULL, FFCASE_GENITIVE
                };
  longopts[6] = (struct option) {"essive", 0, NULL, FFCASE_ESSIVE
                };
  longopts[7] = (struct option) {"translative", 0, NULL, FFCASE_TRANSLATIVE
                };
  longopts[8] = (struct option) {"inessive", 0, NULL, FFCASE_INESSIVE
                };
  longopts[9] = (struct option) {"elative", 0, NULL, FFCASE_ELATIVE
                };
  longopts[10] = (struct option) {"illative", 0, NULL, FFCASE_ILLATIVE
                 };
  longopts[11] = (struct option) {"adessive", 0, NULL, FFCASE_ADESSIVE
                 };
  longopts[12] = (struct option) {"ablative", 0, NULL, FFCASE_ABLATIVE
                 };
  longopts[13] = (struct option) {"allative", 0, NULL, FFCASE_ALLATIVE
                 };
  longopts[14] = (struct option) {"abessive", 0, NULL, FFCASE_ABESSIVE
                 };
  longopts[15] = (struct option) {"comitative", 0, NULL, FFCASE_COMITATIVE
                 };
  longopts[16] = (struct option) {"instructive", 0, NULL, FFCASE_INSTRUCTIVE
                 };

  longopts[17] = (struct option) {"singular", 0, NULL, OPT_SINGULAR
                 };
  longopts[18] = (struct option) {"plural", 0, NULL, OPT_PLURAL
                 };
  longopts[19] = (struct option) {"count", 1, NULL, OPT_COUNT
                 };
  /* ...but if you do, DO remember the all-zero terminator */
  longopts[20] = (struct option) {
                   NULL, 0, NULL, 0
                 };

  while((opt = getopt_long(argc, argv, "Vha", longopts, NULL)) > 0) {
    switch(opt) {
    case 'h':
    case OPT_HELP:
      print_help();
      exit(0);
      break;
    case 'V':
    case OPT_VERSION:
      print_version();
      exit(0);
      break;
    case OPT_ALL:
    case 'a':
      mode = MODE_ALL;
      break;
    case FFCASE_NOMINATIVE:
    case FFCASE_PARTITIVE:
    case FFCASE_GENITIVE:
    case FFCASE_ESSIVE:
    case FFCASE_TRANSLATIVE:
    case FFCASE_INESSIVE:
    case FFCASE_ELATIVE:
    case FFCASE_ILLATIVE:
    case FFCASE_ADESSIVE:
    case FFCASE_ABLATIVE:
    case FFCASE_ALLATIVE:
    case FFCASE_ABESSIVE:
    case FFCASE_COMITATIVE:
    case FFCASE_INSTRUCTIVE:
      thecase = opt;
      break;
    case OPT_SINGULAR:
      count = FFCOUNT_SINGULAR;
      break;
    case OPT_PLURAL:
      count = FFCOUNT_PLURAL;
      break;
    default:
      break;
    }
  }

  if(thecase == FFCASE_COMITATIVE && count == FFCOUNT_SINGULAR) {
    printf("finflect: comitative has no singular form");
    print_help();
    return 1;
  } else if(optind < argc) {
    word = (ffchar*) malloc (strlen(argv[optind]) + 1);
    strcpy(word, argv[optind]);
    if(mode == MODE_NORMAL) {
      ffchar* inflected = ff_inflect(word, thecase, count);
      printf("%s\n", inflected);
      free(inflected);
    } else /* if(mode == MODE_ALL) */
    {
      ffchar *singular, *plural, *casename;
      ffint32 i;
      for(i = FFCASE_NOMINATIVE; i <= FFCASE_INSTRUCTIVE; ++i) {
        casename = ff_case_name((ffcase)i);
        singular = ff_inflect(word, (ffcase)i, FFCOUNT_SINGULAR);
        plural = ff_inflect(word, (ffcase)i, FFCOUNT_PLURAL);
        printf("%s: \t%s\t%s\n", casename, singular, plural);
        free(singular);
        free(plural);
      }
    }
    free(word);
    return 0;
  } else {
    print_help();
    return 1;
  }
}

---