Unit SymbolicNumbers;

                   INTERFACE
 Uses SysUtils ;

 Type
  TGender = ( gMale, gFemale ) ;
  TSymbols = Record
              Digits : Array[ 0 .. 9 , 0 .. 1 ] of String ;
              Dec1s : Array[ 0 .. 9 ] of String ;
              Decs : Array[ 0 .. 9 ] of String ;
              Huns : Array[ 0 .. 9 ] of String ;
              Thousands : Array[ 0 .. 2 ] of String ;
              Millions : Array[ 0 .. 2 ] of String ;
              Milliards : Array[ 0 .. 2 ] of String ;
              Trillions : Array[ 0 .. 2 ] of String ;
              CurrDivider : String ;
             End ;

 Const
  RussianStrings : TSymbols =
   (Digits :
     ( ( 'ноль', 'ноль' ),
       ( 'один', 'одна' ),
       ( 'два', 'две' ),
       ( 'три', 'три' ),
       ( 'четыре', 'четыре' ),
       ( 'пять', 'пять' ),
       ( 'шесть', 'шесть' ),
       ( 'семь', 'семь' ),
       ( 'восемь', 'восемь' ),
       ( 'девять', 'девять' )
     ) ;
    Dec1s :
     ( 'десять',
       'одиннадцать',
       'двенадцать',
       'тринадцать',
       'четырнадцать',
       'пятнадцать',
       'шестнадцать',
       'семнадцать',
       'восемнадцать',
       'девятнадцать' ) ;
    Decs :
     ( '',
       '',
       'двадцать',
       'тридцать',
       'сорок',
       'пятьдесят',
       'шестьдесят',
       'семьдесят',
       'восемьдесят',
       'девяносто' ) ;
    Huns :
     ( '',
       'сто',
       'двести',
       'триста',
       'четыреста',
       'пятьсот',
       'шестьсот',
       'семьсот',
       'восемьсот',
       'девятьсот' ) ;
    Thousands :
     ( 'тысяч',
       'тысяча',
       'тысячи' ) ;
    Millions :
     ( 'миллионов',
       'миллион',
       'миллиона' ) ;
    Milliards :
     ( 'миллиардов',
       'миллиард',
       'миллиарда' ) ;
    Trillions :
     ( 'триллионов',
       'триллион',
       'триллиона' ) ;
    CurrDivider :
     'и' ;
   ) ;
  EnglishStrings : TSymbols =
   (Digits :
     ( ( 'zero', 'zero' ),
       ( 'one', 'one' ),
       ( 'two', 'two' ),
       ( 'three', 'three' ),
       ( 'four', 'four' ),
       ( 'five', 'five' ),
       ( 'six', 'six' ),
       ( 'seven', 'seven' ),
       ( 'eight', 'eight' ),
       ( 'nine', 'nine' )
     ) ;
    Dec1s :
     ( 'ten',
       'eleven',
       'twelve',
       'thirteen',
       'fourteen',
       'fifteen',
       'sixteen',
       'seventeen',
       'eighteen',
       'nineteen' ) ;
    Decs :
     ( '',
       '',
       'twenty',
       'thirty',
       'fourty',
       'fifty',
       'sixty',
       'seventy',
       'eighty',
       'ninety' ) ;
    Huns :
     ( '',
       'one hundred',
       'two hundred',
       'three hundred',
       'four hundred',
       'five hundred',
       'six hundred',
       'seven hundred',
       'eight hundred',
       'nine hundred' ) ;
    Thousands :
     ( 'thousand',
       'thousand',
       'thousand' ) ;
    Millions :
     ( 'million',
       'million',
       'million' ) ;
    Milliards :
     ( 'milliard',
       'milliard',
       'milliard' ) ;
    Trillions :
     ( 'trillion',
       'trillion',
       'trillion' ) ;
    CurrDivider :
     'and' ;
   ) ;

 Var
  Gender : TGender = gMale ;
  Strings : TSymbols ;

 Function IntegerToText( N : Integer ) : String ; OverLoad ;
 Function IntegerToText( N : Int64 ) : String ; OverLoad ;
 Function CurrencyToText( N : Currency ) : String ;

                 IMPLEMENTATION

 Function Digit2String( S : String; G : TGender ) : String ;
  BEGIN           { Digit2String }
   Result := Strings.Digits[Ord( S[ 1 ] ) - Ord('0'), Ord( G )] ;
  END ;           { Digit2String }
 { --------------------------------------------------------------------------}
 

 Function Dec12String( C : Char ) : String ;
  BEGIN           { Digit12String }
   Result := Strings.Dec1s[Ord( C ) - Ord('0')] ;
  END ;           { Digit12String }
 { --------------------------------------------------------------------------}
 

 Function Dec2String( C : Char ) : String ;
  BEGIN           { Dec2String }
   Result := Strings.Decs[Ord( C ) - Ord('0')] ;
  END ;           { Dec2String }
 { --------------------------------------------------------------------------}
 

 Function Hun2String( C : Char ) : String ;
  BEGIN           { Hun2String }
   Result := Strings.Huns[Ord( C ) - Ord('0')] ;
  END ;           { Hun2String }
 { --------------------------------------------------------------------------}
 

 Function Triad( S : String; G : TGender ) : String ;
  Var
   R : String ;
  BEGIN             { Triad }
   Case Length( S ) of
      1  : Result := Digit2String( S, G ) ;
      2  : Case S[ 1 ] of
          '1' : Result := Dec12String( S[ 2 ] ) ;
          else Begin
                Result := Dec2String( S[ 1 ] ) ;
                IF S[ 2 ] <> '0'
                 then
                  IF Length( Result ) >  0 
                   then Result := Result + ' ' + Digit2String( S[ 2 ], G )
                   else Result := Digit2String( S[ 2 ], G )
                 else ;
               End ;
         End ;
      3  : Begin
          R := Hun2String( S[ 1 ] ) ;
          IF Length( R ) >  0 
           then Result := R + ' ' + Triad( Copy( S,  2 ,  2 ), G )
           else Result := Triad( Copy( S,  2 ,  2 ), G ) ;
         End ;
    else Result := ''
   End ; { Case }
  END ;             { Triad }
 { --------------------------------------------------------------------------}
 

 Function Ind( S : String ) : Byte ;
  Var
   L : Word ;
  BEGIN           { Ind }
   L := Length( S ) ;
   IF ( L =  1  ) or ( S[Pred( L )] <> '1' )
    then
     Case S[L] of
      '0'      : Result :=  0  ;
      '1'      : Result :=  1  ;
      '2'..'4' : Result :=  2  ;
      '5'..'9' : Result :=  0  ;
      else Result :=  0  ;
     End
    else Result :=  0  ;
  END ;           { Ind }
 { --------------------------------------------------------------------------}
 

 Function Sym2Text( S : String ) : String ;
  Var
   L      : Word ;
   Le, Ri : String ;
   R      : String ;
  BEGIN         { Sym2Text }
   Case Length( S ) of
           0  : Begin
               Result := '' ;
              End ;
        1 .. 3  : Begin
               Result := Triad( S, Gender ) ;
              End ;
        4 .. 6  : Begin
               L := Length( S ) ;
               Le := Copy( S,  1 , L- 3  ) ;
               Ri := Copy( S, Succ( L- 3  ),  3  ) ;
               R := Triad( Le, gFemale ) ;
               IF Length( R ) >  0 
                then Result := R + ' ' + Strings.Thousands[ Ind( Le ) ] + ' ' + Triad( Ri, Gender )
                else Result := Triad( Ri, Gender ) ;
              End ;
        7 .. 9  : Begin
               L := Length( S ) ;
               Le := Copy( S,  1 , L- 6  ) ;
               Ri := Copy( S, Succ( L- 6  ),  6  ) ;
               R := Triad( Le, gMale ) ;
               IF Length( R ) >  0 
                then Result := R + ' ' + Strings.Millions[ Ind( Le ) ] + ' ' + Sym2Text( Ri )
                else Result := Sym2Text( Ri ) ;
              End ;
      10 .. 12  : Begin
               L := Length( S ) ;
               Le := Copy( S,  1 , L- 9  ) ;
               Ri := Copy( S, Succ( L- 9  ),  9  ) ;
               R := Triad( Le, gMale ) ;
               IF Length( R ) >  0 
                then Result := R + ' ' + Strings.Milliards[ Ind( Le ) ] + ' ' + Sym2Text( Ri )
                else Result := Sym2Text( Ri ) ;
              End ;
      13 .. 15  : Begin
               L := Length( S ) ;
               Le := Copy( S,  1 , L- 12  ) ;
               Ri := Copy( S, Succ( L- 12  ),  12  ) ;
               R := Triad( Le, gMale ) ;
               IF Length( R ) >  0 
                then Result := R + ' ' + Strings.Trillions[ Ind( Le ) ] + ' ' + Sym2Text( Ri )
                else Result := Sym2Text( Ri ) ;
              End ;
     else Result := '' ;
   End ; { Case }
  END ;         { Sym2Text }
 { --------------------------------------------------------------------------}
 

 Function IntegerToText( N : Integer ) : String ;
  BEGIN         { IntegerToText }
   Result := Sym2Text( IntToStr( N ) ) ;
  END ;         { IntegerToText }
 { --------------------------------------------------------------------------}
 

 Function IntegerToText( N : Int64 ) : String ;
  BEGIN         { IntegerToText }
   Result := Sym2Text( IntToStr( N ) ) ;
  END ;         { IntegerToText }
 { --------------------------------------------------------------------------}
 

 Function CurrencyToText( N : Currency ) : String ;
  Var
   S : String ;
   i : Word ;
  BEGIN         { CurrencyToText }
   S := FormatCurr( '0.00', N ) ;
   i := Pos( ',', S ) ;
   Result := Sym2Text( Copy( S,  1 , i- 1  ) ) ;
   IF Length( Copy( S, i+ 1 ,  2  ) ) >  0 
    then Result := Result + ' ' + Strings.CurrDivider + ' ' + Copy( S, i+ 1 ,  2  ) + '/100'
    else ;
  END ;         { CurrencyToText }

END .

  Gender := gMale ;
  Strings := RussianStrings ;