File Coverage

blib/lib/Lingua/Zompist/Barakhinei.pm

Criterion	Covered	Total	%
statement	289	344	84.0
branch	223	328	67.9
condition	118	291	40.5
subroutine	15	15	100.0
pod	9	9	100.0
total	654	987	66.2

package Lingua::Zompist::Barakhinei;
# vim:set sw=2 cin cinkeys-=0#:

use 5.005;
use strict;
# use re 'debug';

require Exporter;
use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
use vars qw($gendertab $pluraltab $rootconstab $subjtab);
use vars qw($cadhctab $cadhgtab $cadhutab);
use vars qw($classtab);
@ISA = qw(Exporter);

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

# This allows declaration	use Lingua::Zompist::Barakhinei ':all';
# If you do not need this, moving things directly into @EXPORT or @EXPORT_OK
# will save memory.
%EXPORT_TAGS = (
  'tabs' => [ qw(
    $gendertab
    $pluraltab
    $rootconstab
    $subjtab
    $cadhutab
    $cadhgtab
    $cadhctab
) ],
  'all' => [ qw(
    demeric
    scrifel
    izhcrifel
    budemeric
    buscrifel
    befel
    part
    noun
    adj
) ],
);

push @{$EXPORT_TAGS{'all'}}, @{$EXPORT_TAGS{'tabs'}};

@EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );

@EXPORT = qw(

);
$VERSION = '0.02';

my %verb = (demeric => \&demeric,
            scrifel => \&scrifel,
            izhcrifel => \&izhcrifel,
            budemeric => \&budemeric,
            buscrifel => \&buscrifel,
            befel => \&befel,
            part => \&part,
           );

my @persons = qw(sû lê ât ta mukh kâ);

my @cases = qw(nom gen acc dat);

my @numbers = qw(sing pl);

# Some handy things for -i- insertion and moving stress
my $cons    = qr/(?:[ctdsknlr]h|[pbtdkgfvszhmnlr])/;
my $consend = qr/[hpbtdkgfvszhmnlr]$/;
my $vow     = qr/[aeiouâêîôûAEIOUÂÊÎÔÛ]/;

# spirant forms
my %spir = (
  d => 'dh',
  t => 'th',
  p => 'v',
);


# Verbs with stems ending in -c in Cadhinor
$cadhctab = {
  'dichi'     => 'DUCIR',
  'faichi'    => 'FAUCIR',
  'farki'     => 'FARCIR',
  'fênki'     => 'VENCIR',
  'foka'      => 'VOCAN',
  'hashki'    => 'HASCIR',
  'hêshki'    => 'HESCIR',
  'kaoka'     => 'CAUCAN',
  'kashki'    => 'KASCIR',
  'kêshkê'    => 'KESCEN',
  'krêshki'   => 'CRESCIR',
  'lachê'     => 'LACEN',
  'lêshkê'    => 'LESCEN',
  'manka'     => 'MANCAN',
  'oloka'     => 'OLOCAN',
  'prechê'    => 'PRECER',
  'rashki'    => 'RASCIR',
  'shkolichê' => 'SCOLICER',
  'snuka'     => 'SNUCAN',
  'tôshkê'    => 'TOSCEN',
  'trankê'    => 'TRANCEN',
};

# Verbs with stems ending in -g in Cadhinor
$cadhgtab = {
  'benhi'  => 'BENGIR',
  'briga'  => 'BRIGAN',
  'fachi'  => 'VAGIR',
  'glonhê' => 'GLONGEC',
  'grochê' => 'GROGEC',
  'hachê'  => 'IAGEN',
  'ilhê'   => 'ULGEC',
  'klachê' => 'CLAGER',
  'kochi'  => 'COGIR',
  'krechê' => 'CREGEN',
  'lega'   => 'LEGAN',
  'mêrgê'  => 'MERGEN',
  'nochê'  => 'NOGEN',
  'puga'   => 'PUGAN',
  'trachê' => 'TRAGEN',
  'troga'  => 'TROGAN',
};

# Verbs with stems ending in -uC in Cadhinor
$cadhutab = {
  'burukha'    => 'BURUKHAN',
  'chidê'      => 'CIUDER',
  'chura'      => 'TURAN',
  'dhirê'      => 'DHUREC',
  'dichi'      => 'DUCIR',
  'dimê'       => 'DUMEC',
  'faichi'     => 'FAUCIR',
  'faoba'      => 'FAUBAN',
  'fedhura'    => 'VETHURAN',
  'fura'       => 'FURAN',
  'glunti'     => 'GLUNTIR',
  'gushta'     => 'GUSTAN',
  'hizi'       => 'IUSIR',
  'idura'      => 'IDURAN',
  'ilhê'       => 'ULGEC',
  'ilubra'     => 'ILUBRAN',
  'ishkuza'    => 'ISKUSAN',
  'izubrê'     => 'ISUBREN',
  'kaoka'      => 'CAUCAN',
  'kitê'       => 'CUTEC',
  'kupi'       => 'CULPIR',
  'kurê'       => 'CURREC',
  'laoda'      => 'LAUDAN',
  'laota'      => 'LAUTAN',
  'liri'       => 'LURIR',
  'lôndura'    => 'LONDURAN',
  'meundê'     => 'MEHUNDEN',
  'niri'       => 'NURIR',
  'plii'       => 'PLUHIR',
  'pua'        => 'PUHAN',
  'puga'       => 'PUGAN',
  'raola'      => 'RAULAN',
  'rênlaoda'   => 'RENLAUDAN',
  'rêshkuli'   => 'RESCULLIR',
  'ridhê'      => 'RUTHER',
  'rizundê'    => 'RISUNDEN',
  'shkechubrê' => 'SCEIUBREN',
  'shpiri'     => 'SPURIR',
  'sidi'       => 'SUDIR',
  'snuka'      => 'SNUCAN',
  'subra'      => 'SUBRAN',
  'sudri'      => 'SUDRIR',
  'taobrê'     => 'TAUBREN',
  'traoda'     => 'TRAUDAN',
  'ubri'       => 'UBRIR',
};

# Verb classes
$classtab = {
}; # %class

# Separate subjunctive stems
$subjtab = {
  'achupua'  => 'achupoa',
  'da'       => 'dona',
  'dichi'    => 'doki',
  'feriê'    => 'fêrsê',
  'fôtê'     => 'fêlsê',
  'hizi'     => 'hôrsi',
  'ihmêta'   => 'ihmêrsa',
  'kêshkê'   => 'kêsê',
  'kolaoda'  => 'koloda',
  'kudichi'  => 'kudoki',
  'laoda'    => 'loda',
  'lega'     => 'loga',
  'lêshkê'   => 'lêsê',
  'mêta'     => 'mêrsa',
  'noê'      => 'nozê',
  'pua'      => 'poa',
  'puga'     => 'poga',
  'rênlaoda' => 'rênloda',
  'rênlelê'  => 'rênlêlsê',
  'shterê'   => 'shtêrsê',
  'sôtê'     => 'sêlsê',
  'subra'    => 'sôbra',
  'tôshkê'   => 'tôsê',
}; # $subjtab


my %demeric = (
  'epeza'     => [ qw( ûzâ ûzê epê epeza epezu ûzôn ) ],
  'eza'       => [ qw( sâ sê ê eza ezu sôn ) ],
  'fâli'      => [ qw( fâl fêl fêl fâlu fâlu fâlîn ) ],
  'foli'      => [ qw( ful ful fut folu folu folîn ) ],
  'hizi'      => [ qw( huz hu hut hizu hizu hizîn ) ],
  'kedhê'     => [ qw( kedhâ kedhê kedhu kedha kedhu kên ) ],
  'lhibê'     => [ qw( lhua lhû lhu lhubu lhubu lôn ) ],
  'nhê'       => [ qw( nhe ni ni nheza nhezu nhên ) ],
  'oi'        => [ qw( oh fi fit ou ou oîn ) ],
  'shkrivê'   => [ qw( shkriva shkri shkri shkrivu shkrivu shkrivôn ) ],
  'shtanê'    => [ qw( shtâ shtê shtê shtana shtanu shtôn ) ],
  'rênshtanê' => [ qw( rênshtâ rênshtê rênshtê rênshtana rênshtanu rênshtôn ) ],
);

sub demeric {
  my $verb  = shift;
  my $class = shift;
  my $stem = $verb;
  my $table;

  return $demeric{$verb} if exists $demeric{$verb};

  if(! defined($class) && exists $classtab->{$verb}) {
    $class = $classtab->{$verb};
  }

  $class = 2 if !defined($class) && $verb =~ /a$/;
  $class = 3 if !defined($class) && $verb =~ /ê$/;
  $class = 4 if !defined($class) && $verb =~ /i$/;
  $class = 0 unless defined $class;

  if($class == 1 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", qw( a û ê u u ôn ) ];
  } elsif($stem =~ s/a$//) {
    $table = [ map "$stem$_", qw( â ê ê a u ôn ) ];
  } elsif($class == 3 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", qw( â ê ê a u ên ) ];
  } elsif($stem =~ s/i$//) {
    $table = [ map "$stem$_", '', qw( û i u u în ) ];
  } elsif($class == 5 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", '', qw( û ê u u un ) ];
  } else {
    return;
  }

  # Cadhinor verbs in -c- and -g-
  if($class == 1 || $class == 4 || $class == 5) {
    for(@{$table}[0,3,4,5]) {
      if(exists $cadhctab->{$verb}) {
        s/ch([auoâô]?n?)$/k$1/;
      } elsif(exists $cadhgtab->{$verb}) {
        s/ch([auoâô]?n?)$/g$1/;
      }
    }
    for(@{$table}[1,2]) {
      if(exists $cadhctab->{$verb}) {
        s/k([eiêîû]n?)$/ch$1/;
      } elsif(exists $cadhgtab->{$verb}) {
        s/g([eiêîû]n?)$/ch$1/;
      }
    }
  } elsif($class == 2 || $class == 3) {
    for(@{$table}[0]) {
      if(exists $cadhctab->{$verb}) {
        s/ch([auoâô]?n?)$/k$1/;
      } elsif(exists $cadhgtab->{$verb}) {
        s/ch([auoâô]?n?)$/g$1/;
      }
    }
    for(@{$table}[1,2]) {
      if(exists $cadhctab->{$verb}) {
        s/k([eiêîû]n?)$/ch$1/;
      } elsif(exists $cadhgtab->{$verb}) {
        s/g([eiêîû]n?)$/ch$1/;
      }
    }
  }

  for(@$table) {
    s/shtu$/kchu/;
    s/sht$/ch/;
    s/g$/k/;
    s/b$/p/;
  }

  # spirantise -d -t -p in 4th and 5th conjugation
  if(($class == 4 || $class == 5) && $verb =~ /$vow[dtp][êai]$/o) {
    for($table->[0]) {
      s/d$/dh/;
      s/t$/th/;
      s/p$/f/;
    }

    for(@{$table}[3,4,5]) {
      s/d(un?|în)$/dh$1/;
      s/t(un?|în)$/th$1/;
      s/p(un?|în)$/v$1/;
    }
  }

  # front and back vowel alternations for Cadhinor verbs in -u-
  if(exists $cadhutab->{$verb}) {
    for(@$table) {
      s/i($cons+[aouâôû]?)$/o$1/;
      s/u($cons+[êiî]n?)$/i$1/;
    }
  }

  return $table;
} # demeric

my %scrifel = (
  'epeza' => [ qw( ûzi ûzi epâ ûzu ûzê ûzîn ) ],
  'eza'   => [ qw( fuch fuch fâ fu fuê fûn ) ],
  'kedhê' => [ qw( kedhi kedhi kiâ kedhu kedhê kedhîn ) ],
);

sub scrifel {
  my $verb  = shift;
  my $class = shift;
  my $stem = $verb;
  my $table;

  return $scrifel{$verb} if exists $scrifel{$verb};

  if(! defined($class) && exists $classtab->{$verb}) {
    $class = $classtab->{$verb};
  }

  $class = 2 if !defined($class) && $verb =~ /a$/;
  $class = 3 if !defined($class) && $verb =~ /ê$/;
  $class = 4 if !defined($class) && $verb =~ /i$/;
  $class = 0 unless defined $class;

  if($class == 1 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", qw( i î ), '', qw( ê ê în ) ];
  } elsif($stem =~ s/a$//) {
    $table = [ map "$stem$_", qw( i i â u ê în ) ];
  } elsif($class == 3 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", qw( i i â u ê în ) ];
  } elsif($stem =~ s/i$//) {
    $table = [ map "$stem$_", qw( i ê â ê ê ên ) ];
  } elsif($class == 5 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", qw( i ê ), '', qw( ê ê ên ) ];
  } else {
    return;
  }

  # Cadhinor verbs in -c- and -g-
  if($class == 1 || $class == 2 || $class == 3) {
    for(@$table) {
      if(exists $cadhctab->{$verb}) {
        s/ch([êâu]?)$/k$1/;
        s/k([iî]n?)$/ch$1/;
      } elsif(exists $cadhgtab->{$verb}) {
        s/ch([êâu]?)$/g$1/;
        s/g([iî]n?)$/ch$1/;
      }
    }
  } elsif($class == 4) {
    for(@{$table}[2]) {
      if(exists $cadhctab->{$verb}) {
        s/ch(â)$/k$1/;
      } elsif(exists $cadhgtab->{$verb}) {
        s/ch(â)$/g$1/;
      }
    }
  }

  for(@$table) {
    s/shtu$/kchu/;
    s/g$/k/;
    s/b$/p/;
  }

  # -sht --> -ch in III.sg for 1st conjugation
  # spirantise -d -t -p in 1st conjugation
  if($class == 1) {
    for($table->[2]) {
      s/sht$/ch/;

      if($verb =~ /$vow[dtp][êai]$/o) {
        s/d$/dh/;
        s/t$/th/;
        s/p$/f/;
      }
    }
  }

  # front and back vowel alternations for Cadhinor verbs in -u-
  if(exists $cadhutab->{$verb}) {
    for(@$table) {
      s/i($cons+[uâ]?)$/o$1/;
      s/u($cons+[êiî]n?)$/i$1/;
    }
  }

  return $table;
} # scrifel

my %izhcrifel = (
  'eza' => [ qw( firi firi furâ furu furê firiôn ) ],
);

sub izhcrifel {
  my $verb  = shift;
  my $class = shift;
  my $stem = $verb;
  my $table;

  return $izhcrifel{$verb} if exists $izhcrifel{$verb};

  if(! defined($class) && exists $classtab->{$verb}) {
    $class = $classtab->{$verb};
  }

  $class = 2 if !defined($class) && $verb =~ /a$/;
  $class = 3 if !defined($class) && $verb =~ /ê$/;
  $class = 4 if !defined($class) && $verb =~ /i$/;
  $class = 0 unless defined $class;

  if($class == 1 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", qw( ri rî êr rê rê rîn ) ];
  } elsif($stem =~ s/a$//) {
    $table = [ map "$stem$_", qw( ri ri râ ru rê rîn ) ];
  } elsif($class == 3 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", qw( ri ri râ ru rê rîn ) ];
  } elsif($stem =~ s/i$//) {
    $table = [ map "$stem$_", qw( ri rê râ rê rê rên ) ];
  } elsif($class == 5 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", qw( ri rê êr rê rê rên ) ];
  } else {
    return;
  }

  return $table;
} # izhcrifel

my %budemeric = (
  'eza' => [ qw( êshta êshtê êshtê êshta êshtu êshtôn ) ],
);

sub budemeric {
  my $verb  = shift;
  my $class = shift;
  my $stem = $verb;
  my $table;

  return $budemeric{$verb} if exists $budemeric{$verb};

  return demeric($subjtab->{$verb}, $class) if exists $subjtab->{$verb};

  if(! defined($class) && exists $classtab->{$verb}) {
    $class = $classtab->{$verb};
  }

  $class = 2 if !defined($class) && $verb =~ /a$/;
  $class = 3 if !defined($class) && $verb =~ /ê$/;
  $class = 4 if !defined($class) && $verb =~ /i$/;
  $class = 0 unless defined $class;

  if($class == 1 && $stem =~ s/ê$/t/) {
    $table = [ map "$stem$_", qw( a ê ê u u ôn ) ];
  } elsif($stem =~ s/a$/m/) {
    $table = [ map "$stem$_", qw( â ê ê a u ôn ) ];
  } elsif($class == 3 && $stem =~ s/ê$/m/) {
    $table = [ map "$stem$_", qw( â ê ê a u ên ) ];
  } elsif($stem =~ s/i$/t/) {
    $table = [ map "$stem$_", '', '', qw( i u u în ) ];
    for(@$table) {
      s/t$/ech/;
      s/tu$/chu/;
      s/t(ti|chu|tîn)$/$1/; # for beshti
    }
  } elsif($class == 5 && $stem =~ s/ê$/t/) {
    $table = [ map "$stem$_", '', '', qw( i u u în ) ];
    for(@$table) {
      s/t$/ech/;
      s/tu$/chu/;
    }
  } else {
    return;
  }

  return $table;
} # budemeric


my %buscrifel = (
  'eza' => [ qw( êshka êshkê êshkê êshka êshku êshkôn ) ],
);

sub buscrifel {
  my $verb  = shift;
  my $class = shift;
  my $stem = $verb;
  my $table;

  return $buscrifel{$verb} if exists $buscrifel{$verb};

  return scrifel($subjtab->{$verb}, $class) if exists $subjtab->{$verb};

  if(! defined($class) && exists $classtab->{$verb}) {
    $class = $classtab->{$verb};
  }

  $class = 2 if !defined($class) && $verb =~ /a$/;
  $class = 3 if !defined($class) && $verb =~ /ê$/;
  $class = 4 if !defined($class) && $verb =~ /i$/;
  $class = 0 unless defined $class;

  if($class == 1 && $stem =~ s/ê$/k/) {
    $table = [ map "$stem$_", qw( a ê ê u u ôn ) ];
    for(@$table) {
      s/kê$/chê/;
    }
  } elsif($stem =~ s/a$/n/) {
    $table = [ map "$stem$_", qw( â ê ê a u ôn ) ];
  } elsif($class == 3 && $stem =~ s/ê$/n/) {
    $table = [ map "$stem$_", qw( â ê ê a u ên ) ];
  } elsif($stem =~ s/i$/r/) {
    $table = [ map "$stem$_", '', '', qw( i u u în ) ];
    for(@$table) {
      s/r$/ir/;
    }
  } elsif($class == 5 && $stem =~ s/ê$/r/) {
    $table = [ map "$stem$_", '', '', qw( i u u în ) ];
    for(@$table) {
      s/r$/ir/;
    }
  } else {
    return;
  }

  return $table;
} # bucrifel


my %befel = (
);

sub befel {
  my $verb = shift;
  my $class = shift;
  my $stem = $verb;
  my $table;

  return $befel{$verb} if exists $befel{$verb};

  if(! defined($class) && exists $classtab->{$verb}) {
    $class = $classtab->{$verb};
  }

  $class = 2 if !defined($class) && $verb =~ /a$/;
  $class = 3 if !defined($class) && $verb =~ /ê$/;
  $class = 4 if !defined($class) && $verb =~ /i$/;
  $class = 0 unless defined $class;

  if($class == 1 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", '', '', 'a', '', 'êl', 'an' ];
  } elsif($stem =~ s/a$//) {
    $table = [ map "$stem$_", '', '', 'a', '', 'el', 'an' ];
  } elsif($class == 3 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", '', '', 'a', '', 'el', 'an' ];
  } elsif($stem =~ s/i$//) {
    $table = [ map "$stem$_", '', '', 'a', '', 'u',  'an' ];
  } elsif($class == 5 && $stem =~ s/ê$//) {
    $table = [ map "$stem$_", '', '', 'a', '', 'u',  'an' ];
  } else {
    return;
  }

  for(@$table) {
    # Cadhinor verbs in -c- and -g-
    if(exists $cadhctab->{$verb}) {
      s/k([eiêîû]?)$/ch/;
    } elsif(exists $cadhgtab->{$verb}) {
      s/g([eiêîû]?)$/ch/;
    }

    s/shtu$/kchu/;
    s/sht(an?)$/kch$1/;
    s/sht$/ch/;
    s/g$/k/;
    s/b$/p/;
  }

  # front and back vowel alternation in II.sg of 2nd and 3rd conjugation
  if($verb =~ /a$/ || $class == 3) {
    for($table->[1]) {
      s/u($cons+)$/i$1/;
    }
  }

  # front and back vowel alternations in III.sg + III.pl
  # and spirantisation
  for(@{$table}[2,5]) {
    s/([dtp])(an?)$/$spir{$1}$2/;
    s/u($cons+an?)$/i$1/;
  }

  # I.sg and I.pl don't exist
  @{$table}[0,3] = (undef, undef);

  return $table;
} # befel


my %part = (
);

# Participles
sub part {
  my $verb = shift;
  my $class = shift;
  my $stem = $verb;

  my($present, $past);

  if(exists $part{$verb}) {
    ($present, $past) = @{ $part{$verb} };
  } else {
    if(! defined($class) && exists $classtab->{$verb}) {
      $class = $classtab->{$verb};
    }

    $class = 2 if !defined($class) && $verb =~ /a$/;
    $class = 3 if !defined($class) && $verb =~ /ê$/;
    $class = 4 if !defined($class) && $verb =~ /i$/;
    $class = 0 unless defined $class;

    if($class == 1 && $stem =~ s/ê$//) {
      ($past, $present) = map "$stem$_", 'êl', 'il';
    } elsif($stem =~ s/a$//) {
      ($past, $present) = map "$stem$_", 'u', 'ê';
    } elsif($class == 3 && $stem =~ s/ê$//) {
      ($past, $present) = map "$stem$_", 'u', 'ê';
    } elsif($stem =~ s/i$//) {
      ($past, $present) = map "$stem$_", 'u', 'i';
    } elsif($class == 5 && $stem =~ s/ê$//) {
      ($past, $present) = map "$stem$_", 'êl', 'ê';
    } else {
      return;
    }
  }

  for($past, $present) {
    # Cadhinor verbs in -c- and -g-
    if(exists $cadhctab->{$verb}) {
      s/ch([auoâô])$/k/;
      s/k([eiêîû])$/ch/;
    } elsif(exists $cadhgtab->{$verb}) {
      s/ch([auoâô]?)$/g/;
      s/g([eiêîû])$/ch/;
    }

    s/shtu$/kchu/;
  }

  return wantarray ? ($present, $past) : [ $present, $past ];
}



$gendertab = {
  'âshta' => 'masc',
  'eli' => 'masc',
  'lônd' => 'masc',

  'kal' => 'neut',
  'manu' => 'neut',
  'nôshti' => 'neut',
  'shkor' => 'neut',
  'shpâ' => 'neut',

  'chir' => 'fem',
  'elorê' => 'fem',
  'kabrâ' => 'fem',
  'medhi' => 'fem',
  'nor' => 'fem',

  'achel' => 'fem',
  'acher' => 'masc',
  'Achirê' => 'fem',
  'âdh' => 'masc',
  'âdhechu' => 'masc',
  'adipa' => 'masc',
  'adlelek' => 'fem',
  'adlelu' => 'fem',
  'air' => 'fem',
}; # $gendertab

$pluraltab = {
  'âshta' => 'âshtâ',
  'eli' => 'eliri',
  'lônd' => 'lôndi',

  'kal' => 'kalo',
  'manu' => 'mani',
  'nôshti' => 'nôkchu',
  'shkor' => 'shkoru',
  'shpâ' => 'shpao',

  'chir' => 'chirâ',
  'elorê' => 'eloriê',
  'kabrâ' => 'kabrachâ',
  'medhi' => 'medhiê',
  'nor' => 'norê',

  'âdhechu' => 'âdhechuni',
}; # $pluraltab

sub noun {
  my $noun = shift;
  my $gender = shift;
  my $plural = shift;
  my $table;

  # is it a pronoun?
  # nom acc dat gen   nom acc/dat gen
  return [ qw( sû   sêth sû  (eri)  ta   tâ (tandê) ) ] if $noun eq 'sû';
  return [ qw( lê   êk   lê  (leri) mukh mî (mundê) ) ] if $noun eq 'lê';
  return [ qw( ât   âtô  âta  âti   kâ   kâ (kandê) ) ] if $noun eq 'ât';
  return [ qw( tot  tô   tota toti  kâ   kâ (kandê) ) ] if $noun eq 'tot';
  return [ qw( kêt  kêtô kêta kêti   ), (undef) x 3   ] if $noun eq 'kêt';
  return [ qw( ta   tâ   tao (tandê) ), (undef) x 3   ] if $noun eq 'ta';
  return [ qw( mukh mî   mî  (mundê) ), (undef) x 3   ] if $noun eq 'mukh';
  return [ qw( kâ   kâ   kâ  (kandê) ), (undef) x 3   ] if $noun eq 'kâ';
  return [ '', qw( zêth zeu zei ), '', qw( zaa zai )  ] if $noun eq 'zê';
  return [ '', qw( zaa  zau zai ),      (undef) x 3   ] if $noun eq 'za';

  # otherwise it's a noun.

  # irregular oblique stem
  return [ qw( pû pû pea peo pei peî peich ) ] if $noun eq 'pû';

  if(!defined($gender) && exists $gendertab->{$noun}) {
    $gender = $gendertab->{$noun};
  }

  if(!defined($gender)) {
    # try to guess based on the ending
    if($noun =~ /a$/) {
      $gender = 'masc';
    } elsif($noun =~ /ê$/) {
      $gender = 'fem';
    } elsif($noun =~ /$consend/o && defined $plural && $plural =~ /i$/) {
      $gender = 'masc'; # can't detect anisosyllabic nouns as they
                        # could be neuter
    } elsif($noun =~ /(?:$cons|i)$/o && defined $plural && $plural =~ /[ou]$/) {
      $gender = 'neut';
    } elsif($noun =~ /â$/ && defined $plural && $plural =~ /ao$/) {
      $gender = 'neut';
    } elsif($noun =~ /(?:$cons|i)$/o && defined $plural && $plural =~ /[âê]$/) {
      $gender = 'fem';
    } elsif($noun =~ /â$/ && defined $plural && $plural =~ /ach$/) {
      $gender = 'fem';
    } else {
      return;
    }
  }

  if(!defined($plural) && exists $pluraltab->{$noun}) {
    $plural = $pluraltab->{$noun};
  }

  if(!defined($plural)) {
    # try to guess based on the ending
    if($noun =~ /$consend/o && $gender eq 'masc') {
      $plural = $noun . 'i'; # assume isosyllabic
    } elsif($noun =~ /a$/ && $gender eq 'masc') {
      ($plural = $noun) =~ s/a$/â/;
    } elsif($noun =~ /u$/ && $gender eq 'masc') {
      $plural = $noun . 'li'; # assume from -ul
    } elsif($noun =~ /$consend/o && $gender eq 'neut') {
      $plural = $noun . 'o'; # more than twice as comman as -u
    } elsif($noun =~ /i$/ && $gender eq 'neut') {
      ($plural = $noun) =~ s/i$/u/;
    } elsif($noun =~ /u$/ && $gender eq 'neut') {
      ($plural = $noun) =~ s/u$/i/;
    } elsif($noun =~ /â$/ && $gender eq 'neut') {
      ($plural = $noun) =~ s/â$/ao/;
    } elsif($noun =~ /$consend/o && $gender eq 'fem') {
      $plural = $noun . 'â'; # "very common"
    } elsif($noun =~ /u$/ && $gender eq 'fem') {
      $plural = $noun . 'lâ'; # assume from -ul
    } elsif($noun =~ /i$/ && $gender eq 'fem') {
      $plural = $noun . 'ê';
    } elsif($noun =~ /ê$/ && $gender eq 'fem') {
      ($plural = $noun) =~ s/ê/iê/;
    } elsif($noun =~ /â$/ && $gender eq 'fem') {
      ($plural = $noun) =~ s/â/achâ/;
    } else {
      return;
    }
  }

  my $sgstem = $noun;
  my $plstem = $plural;

  if($gender eq 'masc') {
    if($sgstem =~ /u$/ && $plstem =~ s/li$//) {
      $table = [ map("$sgstem$_", '', '', 'la', 'lo'),
                 map("$plstem$_", 'li', 'lî', 'lich') ];
    } elsif($plstem =~ s/i$//) {
      $table = [ map("$sgstem$_", '', '', 'a', 'o'),
                 map("$plstem$_", 'i', 'î', 'ich') ];
    } elsif($sgstem =~ s/a$// && $plstem =~ s/â$//) {
      $table = [ map("$sgstem$_", 'a', '', 'a', 'o'),
                 map("$plstem$_", 'â', 'î', 'ach') ];
    } else {
      return;
    }
  } elsif($gender eq 'neut') {
    if($sgstem =~ /$consend/o && $plstem =~ s/o$//) {
      $table = [ map("$sgstem$_", '', 'u', 'u', 'o'),
                 map("$plstem$_", 'o', 'oi', 'och') ];
    } elsif($sgstem =~ /$consend/o && $plstem =~ s/u$//) {
      $table = [ map("$sgstem$_", '', 'u', 'u', 'o'),
                 map("$plstem$_", 'u', 'î', 'ich') ];
    } elsif($sgstem =~ s/i$// && $plstem =~ s/u$//) {
      $table = [ map("$sgstem$_", 'i', 'i', 'i', 'io'),
                 map("$plstem$_", 'u', 'î', 'ich') ];
    } elsif($sgstem =~ s/u$// && $plstem =~ s/i$//) {
      $table = [ map("$sgstem$_", 'u', '', 'u', 'o'),
                 map("$plstem$_", 'i', 'î', 'ich') ];
    } elsif($sgstem =~ s/â$// && $plstem =~ s/ao$//) {
      $table = [ map("$sgstem$_", 'â', 'â', 'â', 'ach'),
                 map("$plstem$_", 'ao', 'aoi', 'aoch') ];
    } else {
      return;
    }
  } elsif($gender eq 'fem') {
    if($sgstem =~ /$consend/o && $plstem =~ s/â$//) {
      $table = [ map("$sgstem$_", '', 'a', 'ê', 'ach'),
                 map("$plstem$_", 'â', 'êi', 'ech') ];
    } elsif($sgstem =~ /$consend/o && $plstem =~ s/ê$//) {
      $table = [ map("$sgstem$_", '', 'e', 'ê', 'ech'),
                 map("$plstem$_", 'ê', 'êi', 'ech') ];
    } elsif($sgstem =~ /i$/ && $plstem =~ s/iê/i/) {
      $table = [ map("$sgstem$_", '', '', 'ê', 'ch'),
                 map("$plstem$_", 'ê', 'a', 'ech') ];
    } elsif($sgstem =~ s/ê$// && $plstem =~ s/ê$//) {
      $table = [ map("$sgstem$_", 'ê', 'e', 'ê', 'ech'),
                 map("$plstem$_", 'ê', 'a', 'ech') ];
    } elsif($sgstem =~ s/â$// && $plstem =~ s/â$//) {
      $table = [ map("$sgstem$_", 'â', 'a', 'ê', 'ach'),
                 map("$plstem$_", 'â', 'a', 'ech') ];
    } elsif($sgstem =~ /u$/ && $plstem =~ s/lâ$//) {
      $table = [ map("$sgstem$_", '', 'la', 'lê', 'lach'),
                 map("$plstem$_", 'lâ', 'lêi', 'lech') ];
    } elsif($sgstem =~ /u$/ && $plstem =~ s/â$//) { # chizu; others?
      $table = [ map("$sgstem$_", '', 'a', 'ê', 'ach'),
                 map("$plstem$_", 'â', 'êi', 'ech') ];
    } else {
      return;
    }
  } else {
    return;
  }

  return $table;
}


# Lost consonants which are restored in all but s.nom. and m.s.acc.

$rootconstab = {
  'andû'  => 'r',
  'aveku' => 'r',
  'dhu'   => 'n',
  'di'    => 'n',
  'du'    => 'r',
  'glûmu' => 'l',
  'kê'    => 'r',
  'kônu'  => 'l',
  'kû'    => 'r',
  'melhu' => 'r',
  'mu'    => 'r',
  'na'    => 'n',
  'osôku' => 'l',
  'rhu'   => 'm',
}; # $rootconstab

sub adj {
  my $adj = shift;
  my $rootcons = shift;
  my $stem = $adj;
  my $table;

  if(!defined($rootcons) && exists $rootconstab->{$adj}) {
    $rootcons = $rootconstab->{$adj};
  }

  $rootcons = '' unless defined $rootcons;

  if($stem =~ /$consend/o || length $rootcons) {
    $table = [ [ $stem, $stem, map "$stem$rootcons$_", qw( a o i î ich ) ],
               [ $stem, map "$stem$rootcons$_", qw( u u o o î ich ) ],
               [ $stem, map "$stem$rootcons$_", qw( a ê ach â êi ech ) ] ];
  } elsif($stem =~ s/ê$//) {
    $table = [ [ map "$stem$_", qw( ê ê a o ê î êch ) ],
               [ map "$stem$_", qw( e ê ê o e ê ech ) ],
               [ map "$stem$_", qw( ê e ê ech ê êi ech ) ] ];
  } elsif($stem =~ s/i$//) {
    $table = [ [ map "$stem$_", 'i', '', qw( i io i î ich ) ],
               [ map "$stem$_", qw( i i i io u î ich ) ],
               [ map "$stem$_", qw( i i iê ich iê ia iech ) ] ];
  } elsif($stem =~ s/â$//) {
    $table = [ [ map "$stem$_", qw( â â â ach ao aoi aoch ) ],
               [ map "$stem$_", qw( â â â ach ao aoi aoch ) ],
               [ map "$stem$_", qw( â a ê ach achâ acha achech ) ] ];
  } else {
    return;
  }

  return $table;
}

1;
__END__