<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in <b>/var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code</b> on line <b>4</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in <b>/var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code</b> on line <b>4</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in <b>/var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code</b> on line <b>4</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in <b>/var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code</b> on line <b>4</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in <b>/var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code</b> on line <b>4</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in <b>/var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code</b> on line <b>4</b><br />
PK      \�Y[��[�,  ,    mutt-ispell-initnu W+A��        # File: ispell-init    -*- muttrc -*-
# Description: Mutt initialization for dictionaries-common support
# Author: Rafael Laboissi�re <rafael@debian.org>
# Created on: Fri Nov 16 18:24:36 CET 2001
# Copyright (C) 2001-2009  Rafael Laboissiere
# ------------------------------------------------------------------
# This file is part of the Debian dictionaries-common package.
# Released under the terms of the GNU GPL (version 2 or later).
# No warranty.

# Usage:
#  Just put 'source /path/to/this/file/mutt-ispell-init' in ~/.muttrc.
#  The `I' key will call the ispell-select script, which uses
#  iselect to interectively choose the ispell dictionary for
#  subsequent spell checkings.  If iselect is not intalled in the system,
#  a fallback rudimentary interface is used.
#
#  Unsetting the wait_key configuration variable is recommended, since
#  a shell-escape function is called.

macro generic I "<shell-escape>/usr/bin/select-default-iwrap\n" \
      "Select the default ispell dictionary for use with ispell-wrapper"

set ispell = "/usr/bin/ispell-wrapper"
PK      \�Y[�(��B>  B>    dc-debconf-default-value.plnu W+A��        # ----------------------------------------------------------------------------
# dc-debconf-default-value.pl:
#  Dealing with default value selection. Functions and definitions.
# ----------------------------------------------------------------------------

# Trying to find a reasonable guess for default ispell dictionary and wordlist
# from the debian-installer settings, envvars or pre-policy symlinks and the
# list of ispell dictionaries and wordlists to be installed

$priority{"ispell"}   = "critical"; # These will be changed later,
$priority{"wordlist"} = "critical"; # Do not change value here.
$dcscript             = "/usr/share/dictionaries-common/dc-debconf-select.pl";
$fromdcconfig         = "yes";
$debug                = "yes" if exists $ENV{'DICT_COMMON_DEBUG'};


my %debconf_vals = ();
my @suffixes     = ("","-large","-medium","-small","-gut");
my %equivs       = ("bg"      => "bulgarian",
		    "ca"      => "catalan",
		    "cs"      => "czech",
		    "da"      => "danish",
		    "de"      => "ngerman",
		    "de:1"    => "ogerman",
		    "de_CH"   => "swiss",
		    "en_US"   => "american",
		    "en_US:1" => "miscfiles",
		    "en_CA"   => "canadian",
		    "en_CA:1" => "american",
		    "en_GB"   => "british",
		    "en_AU"   => "british",
		    "eo"      => "esperanto",
		    "es"      => "spanish",
		    "fi"      => "finnish",
		    "fo"      => "faroese",
		    "fr"      => "french",
		    "ga"      => "irish",
		    "gd"      => "gaelic",
		    "gl"      => "galician-minimos",
		    "gv"      => "manx",
		    "hu"      => "hungarian",
		    "it"      => "italian",
		    "lt"      => "lithuanian",
		    "nb"      => "norwegian->bokma",    # Match bokmal and bokmaal
		    "nl"      => "dutch",
		    "nn"      => "norwegian->nynorsk",
		    "pl"      => "polish",
		    "pt"      => "portuguese",
		    "pt_BR"   => "brazilian",
		    "ru"      => "russian",
		    "sv"      => "swedish",
		    "tl"      => "tagalog",
		    "uk"      => "ukrainian");
my %pending_keys   = ();
my %alternatives   = ("ispell"   => "ispell-dictionary.hash",
		      "wordlist" => "dictionary");

# -------------------------------------------------------------
sub dc_debugprint(){
# -------------------------------------------------------------
# Show info if in debug mode
# -------------------------------------------------------------
  print STDERR "@_" if $debug;
}

# -------------------------------------------------------------
sub dc_set (){
# -------------------------------------------------------------
# Set debconf value unless already set
# -------------------------------------------------------------
  my $question  = shift;
  my $value     = shift;
  my $priority  = $priority{$class} || "";

  my ($errorcode, $oldvalue) = get($question);

  $oldvalue = "unset" unless $oldvalue;

  if ( $errorcode or $oldvalue eq "unset" ){
    &dc_debugprint(" $question: errorcode: $errorcode; priority: $priority\n" .
		   " Old:[$oldvalue] --> New:[$value]\n");
    set("$question","$value");
  } elsif ( $oldvalue eq $value ) {
    print STDERR "Info: $question is already set to
      [$oldvalue]. Preserving it.\n";
  } else {
    print STDERR "Warning: $question is already set to
      [$oldvalue].
      Not setting to [$value]\n";
  }

  if ( $debug ){                 # --- Check if question value is actually set
    ($errorcode, $oldvalue) = get($question);
    if ( $errorcode ){
      print STDERR " dictionaries-common: $question reading failed with $errorcode\n";
    } elsif ( $oldvalue) {
      print STDERR " dictionaries-common: $question actually set to [$oldvalue]\n";
    } else {
      print STDERR " dictionaries-common: $question value is void, bad thing\n";
    }
  }
  &dc_debugprint ("Not tried: " . join(', ',sort keys %pending_keys) . "\n");
}

# -------------------------------------------------------------
sub dc_extractlangname (){
# -------------------------------------------------------------
# Look if a dict matching $langkey in %equivs is to be installed
# and return the preferred language name if so.
# -------------------------------------------------------------
  my $langkey     = shift;
  my $classprefix = shift;
  my $thestring   = '';
  my $thepackage  = '';
  my $thevariant  = '';
  my @thevalues   = ();

  if ( exists $pending_keys{$langkey} ){ # Make sure we do not try it again
    &dc_debugprint("Trying langkey \"$langkey\" with classprefix \"$classprefix\"\n");
    delete $pending_keys{$langkey};
  } else {
    if ( exists $equivs{$langkey} ){
      # This $langkey was already tried, no need to try it again
      &dc_debugprint("Already done langkey $langkey\n");
    } else {
      # This $langkey does not exist
      &dc_debugprint("Non-existant langkey $langkey\n");
    }
    return;
  }

  if ( exists $equivs{$langkey} ){
    ($thepackage,$thevariant) = split ("->",$equivs{$langkey});
    foreach $suffix ( @suffixes ){
      if ( $thepackage eq "miscfiles" ){
	$pkgfullname = "$thepackage$suffix";
      } else {
	$pkgfullname = "$classprefix$thepackage$suffix";
      }
      &dc_debugprint(" Trying package $pkgfullname\n");
      if ( exists $debconf_vals{"$pkgfullname"} ){
	if ( exists $debconf_defaultvals{"$pkgfullname"} ){
	  $thestring = $debconf_defaultvals{"$pkgfullname"};
	} else {
	  $thestring = $debconf_vals{"$pkgfullname"};
	}
	@thevalues = sort split (/\s*,\s*/,$thestring);
	if ( $thevariant ){
	  @thevalues = grep {/$thevariant/i} @thevalues;
	}
	@thevalues = sort {
	  $a =~ m/tex/i <=> $b =~ m/tex/i # Sort tex variants last
	    ||
	  $a cmp $b } @thevalues;
	if ( scalar @thevalues >= 1 ){
	  return "$thevalues[0]";
	} else {
	  return;
	}
      }
    }
  }
}

# -------------------------------------------------------------
sub dc_guesslang (){
# -------------------------------------------------------------
# Try different combinations of $language and $country and possible
# fallbacks in case dc_extractlangname() does not find a good guess
# -------------------------------------------------------------
  my $class              = shift;
  my $language           = shift;
  my $country            = shift;
  my $guessed            = '';
  my @possible_fallbacks = ();
  my $classprefix        = substr($class,0,1);
  my $msgprefix          = "dict-common->dc_guesslang";

  &dc_debugprint("$msgprefix: Looking for langkey matches [$class,$classprefix,$language,$country].\n");
  if ( $guessed = &dc_extractlangname("$language" . "_" . uc($country),$classprefix)
       || &dc_extractlangname("$language" . "_" . uc("$country") . ":1",$classprefix)
       || &dc_extractlangname("$language",$classprefix)
       || &dc_extractlangname("$language:1",$classprefix)
    ){
    $priority{$class} = "low";
    return $guessed;
  } else {
    @possible_fallbacks = grep {/$language\_/} sort keys %equivs;
    $priority{$class} = "medium";
    foreach ( @possible_fallbacks ){
      return $guessed if ( $guessed = &dc_extractlangname($_,$classprefix));
    }
    $priority{$class} = "high";
    return;
  }
}

# -------------------------------------------------------------
sub dc_guessotherlang (){
# -------------------------------------------------------------
# Iterate over the not yet tried $langkey values for a dict to be
# installed. Return first match
# -------------------------------------------------------------
  my $guessed = '';

  foreach ( sort keys %pending_keys ){
    return $guessed if ( $guessed = &dc_extractlangname($_));
  }
}

# -------------------------------------------------------------
sub dc_guess_langkey_for_link(){
# -------------------------------------------------------------
# Try guessing langkey after (woody or older) former symlink
# -------------------------------------------------------------
  my $class      = shift;
  my $prefix     = '';
  my $guess      = '';
  my $language   = '';
  my $link       = "/etc/alternatives/$alternatives{$class}";
  my %reverse_equivs = ();

  return unless ( -l $link );

  if ( $guess = readlink($link) ){
    &dc_debugprint("dictionaries-common.config: Found pre-policy link $link->$guess.");

    $guess =~ s/\.hash$//;
    $guess =~ s/^.*\///;
    $guess =~ s/(\-\.)(small|medium|large)$//;
    $guess =~ s/\-english$//;

    $guess = "norwegian->bokma"   if ($guess eq "bokm�l");
    $guess = "norwegian->nynorsk" if ($guess eq "nynorsk");
    $guess = "ogerman"            if ($guess eq "german");
    $guess = "miscfiles"          if ($guess eq "web2");
    $guess = "danish"             if ($guess eq "dansk");
    $guess = "french"             if ($guess eq "francais");
    $guess = "swedish"            if ($guess eq "svenska");

    &dc_debugprint("dictionaries-common.config: pre-policy link target fine tuned to $guess.\n");

    # Build reverse equivs
    foreach ( keys %equivs ){
      $reverse_equivs{$equivs{$_}} = $_;
    }

    # Check for a match and return langkey if found
    if ( exists $reverse_equivs{$guess} ){
      return $reverse_equivs{$guess};
    } else {
      &dc_debugprint("dictionaries-common.config: No match found for pre-policy symlink $link.\n");
    }
  }
}

# -------------------------------------------------------------
sub dc_manual_alternative (){
# -------------------------------------------------------------
# Check if woody (or older) alternative exists and is set to manual
# -------------------------------------------------------------
  my $class  = shift;
  my $file   = "/var/lib/dpkg/alternatives/$alternatives{$class}";
  my $status = '';

  if ( -r $file ){
    open(FILE,"< $file") or return;
    $status = <FILE>;
    close FILE;
    $status = "" unless $status;
    chomp $status;
    return "Manual (previous alternative setting)" if ( $status eq "manual" );
  }
}

# -------------------------------------------------------------
sub dc_debconf_rebuild (){
# -------------------------------------------------------------
# Gather info from debconf for the (to be) installed packages for class
#   %debconf_vals         : pkg -> languages provided by package
#   %debconf_defaultvals  : pkg -> default language for package
# -------------------------------------------------------------
  my $class = shift;
  return unless $class;
  my $question = "shared/packages-$class";
  my ($errorcode,$pkgowners) = metaget ($question, "owners");
  return if $errorcode;

  %debconf_vals = ();
  %debconf_defaultvals = ();
  foreach ( split (/\s*,\s*/,$pkgowners) ){
    #$debconf_vals{$_} = metaget ("$_/languages", "default");
    $debconf_vals{$_} = get ("$_/languages");
    my ($errorcode,$pkgdefaults) = get ("$_/defaults");
    $debconf_defaultvals{$_} = $pkgdefaults if not $errorcode;
  }
  return "ok";
}

# -----------------------------------------------------------------
sub dc_guess_language_country_strings (){
# -----------------------------------------------------------------
# Try guessing $language $country pairs
# -----------------------------------------------------------------
  my $class       = shift;

  my $di_language = "debian-installer/language";
  my $di_country  = "debian-installer/country";
  my $msgstring   = "dict-common.config->dc_guess_language_country_strings";

  my $language;
  my $country;
  my $errorcode;

  # First check if we are upgrading from ancient pre-policy setup with
  # symlinks set through alternatives and try guessing a langkey
  if ( $language = &dc_guess_langkey_for_link($class) ){
    &dc_debugprint("$msgstring: Guessed langkey $language from ancient pre-policy symlink.\n");
  } else {
    # If system is already installed use /etc/default/locale contents.
    # Otherwise try looking at debian-installer/language
    if ( -e "/etc/default/locale" ){
      $language = $ENV{'LANG'} if exists $ENV{'LANG'};
    }
    if ( $language ){
      &dc_debugprint("$msgstring: LANG=$language is to be used.\n") if $language;
    } else {
      ($errorcode,$language) = get($di_language);
      $language = '' if $errorcode;
      &dc_debugprint("$msgstring: Debconf gives language \"$language\"\n") if $language;
    }
  }

  # Try hard to get a value if nothing was found
  $language = $language ||
    $ENV{'LANG'} ||
    $ENV{'LC_MESSAGES'} ||
    $ENV{'LC_ALL'} ||
    '';

  # Get proper $language $country pairs if $language is available.
  if ( $language ){
    $language = "en" if ( $language eq "C" );
    # Deal with de_DE:de_DE@euro:de:en_GB.UTF-8:en like entries
    $language = ( split(":",$language) )[0];
    $language =~ s/[\.@].*$//;                # Remove variant and charset
    ($language,$country) = split("_",$language);
    if ( not $country ){
      ($errorcode,$country) = get($di_country);
      if ( $errorcode or not $country ){
	$country = "unset";
      }
    }

    # Make sure there is no leading/trailing whitespace.
    $language =~ s/^\s+//;
    $language =~ s/\s+$//;
    $country  =~ s/^\s+//;
    $country  =~ s/\s+$//;

  } else {
    &dc_debugprint("$msgstring: No language candidate found. Defaulting to \"en_UNSET\"\n");
    $language = "en";
    $country  = "UNSET";
  }
  return $language, $country;
}

# -----------------------------------------------------------------
sub dc_set_default_value_for_class (){
# -----------------------------------------------------------------
# Try guessing a reasonable default value for given class after
# $language $country pair and set it if found.
# -----------------------------------------------------------------
  my $class       = shift;
  my $guessed;
  my $msgprefix   = "dict-common.config->dc_set_default_value_for_class";
  my $question    = "dictionaries-common/default-$class";
  my $oldlink     = "/etc/alternatives/$alternatives{$class}";

  if ( &dc_debconf_rebuild($class) ){
    # Ancient symlinks may be different for different classes,
    my ( $language, $country ) = &dc_guess_language_country_strings($class);
    %pending_keys              = %equivs;

    # First try something reasonably close to the lang +country pair
    if ( $guessed = &dc_guesslang($class,$language,$country) ){
      &dc_debugprint("$msgprefix: Guessed value ->($class,$language,$country,$guessed)\n");
    } else {
      if ( $guessed = &dc_guesslang($class,"en","US")   # Try an English variant
	   || &dc_guessotherlang ){                     # Try anything
	&dc_debugprint("$msgprefix: Forcing [$guessed] for ($class,$language,$country)\n");
	$priority{$class} = "medium";
      } else {
	# Signal an error. This should never happen, so the critical priority.
	&dc_debugprint("$msgprefix: No good or bad guess found for ($class,$language,$country)\n");
	$priority{$class} = "critical";
      }
    }

    # We may have ancient pre-policy alternative based symlinks with
    # alternative set in manual mode or with more dictionaries installed
    # in the same run. This is an upgrade from an ancient setup, we better ask.
    if ( -l $oldlink ){
      if ( &dc_manual_alternative($class) ){
	&dc_debugprint("$msgprefix: Ancient $class alternative was in manual mode. Setting critical priority\n");
	$priority{$class} = "critical";
      } else {
	foreach ( keys %debconf_vals ){
	  my $oldpackage = $_;
	  next if ( $oldpackage eq "dictionaries-common" );
	  $oldpackage = "wenglish" if ( $oldpackage eq "wamerican" );
	  # critical priority if exists debconf entry without a
	  # previous package installed. This means that besides
	  # upgrading, new dicts are being installed.
	  if ( not -e "/var/lib/dpkg/info/$oldpackage.list" ){
	    $priority{$class} = "critical";
	    &dc_debugprint("$msgprefix: New dict [$oldpackage] is to be installed\n");
	    last;
	  }
	}
      }
    }

    # Actually set the value if found
    &dc_set($question,$guessed) if $guessed;
  } else {
    &dc_debugprint("$msgprefix: No elements found for $class\n");
  }
  return $guessed;
}

1;

# -----------------------------------------------------------------
# Local Variables:
# perl-indent-level: 2
# coding: iso-8859-1
# End:

PK      \�Y[            
  elanguagesnu W+A��        PK      \�Y[����  �    dc-debconf-select.plnu W+A��        # ---------------------------------------------------------------------------
# dc-debconf-select.pl:
#  This file will be added to end of dictionaries-common.config-base
#  to make dictionaries-common.config, as well as installed under
#  /usr/share/dictionaries-common for single ispell dicts/wordlists use
# ---------------------------------------------------------------------------

sub dico_get_packages (){
  # Get list of packages sharing the question
  my $class    = shift;
  my $question = "shared/packages-$class";

  my ($errorcode,$packages) = metaget ($question, "owners");
  return [ split (/\s*,\s*/, $packages) ] unless $errorcode;
}

sub dico_parse_languages (){
  # Get a hash reference of package -> list of (e)languages provided by package
  my $class    = shift;
  my $variant  = shift;
  my $packages = shift;
  my %tmphash  = ();

  die "No variant (languages|elanguages) string supplied\n" unless $variant;

  $packages = &dico_get_packages($class) unless $packages;

  foreach $pkg ( @$packages ){
    my ($errorcode, $entry ) = metaget("$pkg/$variant", "default");
    unless ( $errorcode ){
      $entry =~ s/^\s+//;
      $entry =~ s/\s+$//;
      $tmphash{$pkg} = $entry;
    }
  }
  return \%tmphash;
}

sub dico_get_all_choices (){
  # Get $choices and $echoices parallel lists sorted after $echoices and formatted for debconf
  my $class       = shift;
  my $languages   = shift;
  my $debug       = 1 if exists $ENV{'DICT_COMMON_DEBUG'};
  my %mappinghash = ();
  my $debug_prefix = "[$class,dico_get_all_choices]";

  $languages   = &dico_parse_languages($class,"languages") unless $languages;

  my $elanguages  = &dico_parse_languages($class,"elanguages",[ keys %$languages ]);

  if ( $debug ){
    print STDERR "-------- $debug_prefix start --------\n";
    my $langlist  = join(', ',sort keys %{$languages});
    my $elanglist = join(', ',sort keys %{$elanguages});
    print STDERR " * Packages with languages: $langlist\n"  if $debug;
    print STDERR " * Packages with elanguages: $elanglist\n" if $debug;
  }

  foreach $pkg ( keys %$languages ){
    my @langs  = split(/\s*,\s*/, $languages->{$pkg});
    my @elangs = @langs;
    if ( exists $elanguages->{$pkg} ){
      my @tmp = split(/\s*,\s*/, $elanguages->{$pkg});
      if ( $debug ){
	print STDERR " langs: $#langs, "  . join(', ',@langs)  . "\n";
	print STDERR " tmp:   $#tmp, "    . join(', ',@tmp)    . "\n";
      }
      @elangs = @tmp if ( $#langs == $#tmp );
    }
    foreach $index ( 0 .. $#langs ){
      $mappinghash{$langs[$index]} = $elangs[$index];
    }
  }
  my $echoices = join(', ', sort {lc($a) cmp lc($b)} values %mappinghash);
  my $choices  = join(', ',
		      sort {lc($mappinghash{$a}) cmp lc($mappinghash{$b})}
		      keys %mappinghash);
  if ( $debug ){
    print STDERR "- Choices:\n[$choices]\n";
    print STDERR "- Echoices:\n[$echoices]\n";
    print STDERR "-------- $debug_prefix end --------\n";
  }
  return $choices, $echoices;
}

sub dc_debconf_select (){
  my $class       = shift;
  my $priority    = shift;
  my $question    = "dictionaries-common/default-$class";
  my $packages    = &dico_get_packages($class);
  my $debug       = 1 if exists $ENV{'DICT_COMMON_DEBUG'};
  my $reconfigure = 1 if exists $ENV{'DEBCONF_RECONFIGURE'};
  my $flagdir     = "/var/cache/dictionaries-common";
  my $newflag     = "$flagdir/flag-$class-new";
  my $langscript  = "/usr/share/dictionaries-common/dc-debconf-default-value.pl";
  my $echoices;
  my @oldchoices  = ();
  my %newchoices  = ();
  my %title       = ('ispell'   => "Dictionaries-common: Ispell dictionary",
		     'wordlist' => "Dictionaries-common: Wordlist dictionary"
		     );
  my $debug_prefix = "[$class,dc_debconf_select]";

  return unless $packages;

  print STDERR "----- $debug_prefix start -----------\n" if $debug;

  # Get new base list of provided languages
  my $languages = &dico_parse_languages($class,"languages",$packages);
  foreach $pkg ( keys %$languages ) {
    foreach $lang ( split(/\s*,\s*/, $languages->{$pkg}) ){
      $newchoices{$lang}++;
    }
  }
  my $choices = join (', ', sort {lc($a) cmp lc($b)} keys %newchoices);

  # Get old list of provided languages
  @oldchoices = split(/\s*,\s*/,metaget ($question, "choices-c"));
  pop @oldchoices;            # Remove the manual entry
  my $oldchoices = join (', ', sort {lc($a) cmp lc($b)} @oldchoices);

  # If dictionaries-common is already installed (-r $langscript),
  # there are elements for this chass to be installed (%newchoices)
  # and there were none before (! $oldchoices), means that we are installing
  # for the first time elements in this class, with dictionaries-common
  # already installed. Try getting a reasonable default value
  if ( -r $langscript && %newchoices && ! $oldchoices ){
    print STDERR "$debug_prefix: Configuring $class class for the first time\n\n" if $debug;
    require $langscript;
    &dc_set_default_value_for_class($class);
  }

  # Read current value of default ispell dict / wordlist.
  my $curval  = get ($question) || "undefined";

  if ( scalar %newchoices ) {
    # If $priority is set &dc_set_default_value_for_class found something.
    # This will usually be as much "medium", so honour it.
    unless ( $priority ){
      if ( $curval =~ /^Manual.*/ or exists $newchoices{$curval} ){
	# Use priority "medium" if current value is in the new list or mode is set to manual.
	$priority = "medium";     #
      } else {
	# Otherwise we have a wrong value with no associated entry.
	# This is an *error* that needs to be signalled and acted upon.
	# For this reason priority must be higher than the standard one.
	# We leave it as "high" instead of "critical" so question can be
	# overriden in special cases until underlying bug is fixed.
	print STDERR "$debug_prefix error: [$curval] does not correspond to any package\n";
	$priority = "high";
      }
    }
  } else {
    $priority = "low";
    print STDERR "$debug_prefix info: No elements in given class.\n" if $debug;
  }

  print STDERR
    "$debug_prefix:\n" .
    " Class: $class, Priority: $priority\n" .
    " Question: $question, Previous or guessed value: $curval\n" .
    " New choices:[$choices]\n" .
    " Old choices:[$oldchoices]\n" if $debug;

  # May ask question if there is no match
  if ( scalar %newchoices ) {
    if ( $choices ne $oldchoices) {
      fset ($question, "seen", "false");
      # Let future processes in this apt run know that a new $class element is to be installed
      if ( -d $flagdir ) {
	open ($FLAG,"> $newflag")
	  or die "Could not open $newflag for write. Aborting ...\n";
	print $FLAG "1\n";
	close $FLAG;
      }
    }
    my ( $errorcode, $seen ) = fget($question, "seen");
    if ( $seen eq "false" or $reconfigure ){
      ($choices, $echoices ) = &dico_get_all_choices($class,$languages);
      subst ($question, "choices", $choices);
      subst ($question, "echoices", $echoices);
    }
    input ($priority, $question);
    title ($title{$class});
    go ();
    subst ($question, "echoices", $choices); # Be backwards consistent
  }

  # If called from dictionaries-common.config, check actual values in debug mode
  if ( $debug && $fromdcconfig ){
    print STDERR "dictionaries-common.config: Checking really set values for $question\n";
    print STDERR " Choices-C string: " . metaget ($question, "choices-c") . "\n";
    print STDERR " Really set value: " . get ($question) . "\n";
  }
  print STDERR "----- $debug_prefix end -----------\n" if $debug;
}

# Local Variables:
# perl-indent-level: 2
# End:

1;

PK      �Y[�b��   �     sqspell.phpnu W+A��        <?php
### This file is part of the dictionaries-common package.
### It has been automatically generated.
### DO NOT EDIT!
$SQSPELL_APP = array (
  'American English (ispell)' => 'ispell -a    -B -d american'
);
PK      �Y[c�
��  �    wordlist.dbnu W+A��        ### This file is part of the dictionaries-common package.
### It has been automatically generated.
### DO NOT EDIT!

%dictionaries = (
  'suomi (Finnish)' => {
     'additionalchars' => '��������������������',
     'casechars' => '[A-Za-z\\345\\344\\366\\351\\340\\374\\350\\346\\370\\347\\305\\304\\326\\311\\300\\334\\310\\306\\330\\307]',
     'coding-system' => 'iso-8859-1',
     'emacsen-name' => 'finnish',
     'hash-name' => 'finnish',
     'ispell-args' => '-C -m -d finnish',
     'not-casechars' => '[^A-Za-z\\345\\344\\366\\351\\340\\374\\350\\346\\370\\347\\305\\304\\326\\311\\300\\334\\310\\306\\330\\307]',
     'otherchars' => '[\']'
  }
);

1;
PK      �Y[dyf	�   �     emacsen-ispell-default.elnu W+A��        ;; File automatically generated by update-default-ispell
;;
;; Do not manually edit!! Use select-default-ispell script instead

(set-variable 'debian-ispell-dictionary "american")
PK      �Y[?��;�  �    emacsen-ispell-dicts.elnu W+A��        ;;; This file is part of the dictionaries-common package.
;;; It has been automatically generated.
;;; DO NOT EDIT!

;; Adding ispell dicts

(add-to-list 'debian-ispell-only-dictionary-alist
  '("american"
     "[A-Za-z]"
     "[^A-Za-z]"
     "[']"
     nil
     ("-B" "-d" "american")
     nil
     iso-8859-1))


;; No emacsen-aspell-equivs entries were found


;; No emacsen-hunspell-equivs entries were found
PK      �Y[��c�   �   	  aspell.dbnu W+A��        ### This file is part of the dictionaries-common package.
### It has been automatically generated.
### DO NOT EDIT!

%dictionaries = (

);

1;
PK      �Y[�ec      jed-ispell-dicts.slnu W+A��        %%% This file is part of the dictionaries-common package.
%%% It has been automatically generated.
%%% DO NOT EDIT!

#ifexists ispell_add_dictionary
  ispell_add_dictionary (
    "american",
    "american",
    "",
    "'",
    "",
    "-B -d american");
#endif
PK      �Y[��        ispell-dicts-list.txtnu W+A��        american (American English)
PK      �Y[��`X�  �  	  ispell.dbnu W+A��        ### This file is part of the dictionaries-common package.
### It has been automatically generated.
### DO NOT EDIT!

%dictionaries = (
  'american (American English)' => {
     'casechars' => '[A-Za-z]',
     'coding-system' => 'iso-8859-1',
     'emacsen-name' => 'american',
     'hash-name' => 'american',
     'ispell-args' => '-B -d american',
     'locale' => 'en_us',
     'not-casechars' => '[^A-Za-z]',
     'otherchars' => '[\']',
     'pspell-ispell' => 'en-american iso8859-1'
  }
);

1;
PK      �Y[��c�   �     hunspell.dbnu W+A��        ### This file is part of the dictionaries-common package.
### It has been automatically generated.
### DO NOT EDIT!

%dictionaries = (

);

1;
PK        \�Y[��[�,  ,                  mutt-ispell-initnu W+A��        PK        \�Y[�(��B>  B>              l  dc-debconf-default-value.plnu W+A��        PK        \�Y[            
            �B  elanguagesnu W+A��        PK        \�Y[����  �              3C  dc-debconf-select.plnu W+A��        PK        �Y[�b��   �               �`  sqspell.phpnu W+A��        PK        �Y[c�
��  �              b  wordlist.dbnu W+A��        PK        �Y[dyf	�   �               �d  emacsen-ispell-default.elnu W+A��        PK        �Y[?��;�  �              �e  emacsen-ispell-dicts.elnu W+A��        PK        �Y[��c�   �   	            �g  aspell.dbnu W+A��        PK        �Y[�ec                �h  jed-ispell-dicts.slnu W+A��        PK        �Y[��                  �i  ispell-dicts-list.txtnu W+A��        PK        �Y[��`X�  �  	            -j  ispell.dbnu W+A��        PK        �Y[��c�   �               Zl  hunspell.dbnu W+A��        PK        $m    