gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/misc/genstatistics.perl

@@ -0,0 +1,178 @@
+#!/usr/bin/perl
+#
+#  Main authors:
+#     Christian Schulte <schulte@gecode.org>
+#
+#  Copyright:
+#     Christian Schulte, 2005
+#
+#  Last modified:
+#     $Date: 2008-02-28 00:31:18 +0100 (Thu, 28 Feb 2008) $ by $Author: schulte $
+#     $Revision: 6336 $
+#
+#  This file is part of Gecode, the generic constraint
+#  development environment:
+#     http://www.gecode.org
+#
+#  Permission is hereby granted, free of charge, to any person obtaining
+#  a copy of this software and associated documentation files (the
+#  "Software"), to deal in the Software without restriction, including
+#  without limitation the rights to use, copy, modify, merge, publish,
+#  distribute, sublicense, and/or sell copies of the Software, and to
+#  permit persons to whom the Software is furnished to do so, subject to
+#  the following conditions:
+#
+#  The above copyright notice and this permission notice shall be
+#  included in all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+#
+
+#
+# Get statistics for all files
+#
+
+$i = 0;
+
+while ($file = @ARGV[$i++]) {
+  open(FILE,"<$file");
+  my $module = "UNKNOWN";
+  my $cat    = "UNKNOWN";
+  my $n_blank;
+  my $n_comment;
+  my $n_code;
+  my $n_class;
+  while ($l = <FILE>) {
+    if ($l =~ /\/\/ STATISTICS: ([A-Za-z]+)-([A-Za-z]+)/) {
+      $module = $1;
+      $cat    = $2;
+    }
+    if ($l =~ /^[ \t]*$/) {
+      $n_blank += 1;
+    } elsif ($l =~ /^[ \t]*\/\//) {
+      $n_comment += 1;
+    } elsif ($l =~ /\/\*/) {
+      $n_comment += 1;
+      while (!($l =~ /\*\//) && ($l = <FILE>)) {
+	$n_comment += 1;
+      }
+    } else {
+      $n_code += 1;
+    }
+    if ($l =~ /class [A-Za-z_][A-Za-z0-9_]*.*\{/) {
+      $n_class += 1;
+    }
+  }
+  if ($module eq "UNKNOWN") {
+    print "UNKNOWN: $file\n";
+    exit 1;
+  }
+  $m{$module} = 1;
+  $c{$cat} = 1;
+  $class{"$module-$cat"} += $n_class;
+  $comment{"$module-$cat"} += $n_comment;
+  $blank{"$module-$cat"} += $n_blank;
+  $code{"$module-$cat"} += $n_code;
+  close FILE;
+}
+
+@modorder = ("kernel","search","int","set","cpltset","minimodel",
+	     "serialization", "iter","support","example","test");
+
+@catorder = ("core","var","prop","branch","post","search",
+	     "int","set","cpltset","minimodel","stress","any","other");
+$i = 0;
+
+$modclear{"kernel"} = "Kernel";
+$modclear{"search"} = "Search engines";
+$modclear{"int"} = "Finite domain integers";
+$modclear{"set"} = "Finite integer sets";
+$modclear{"cpltset"} =
+  "Finite integer sets with complete domain representation";
+$modclear{"minimodel"} = "Minimal modelling support";
+$modclear{"serialization"} = "Serialization support";
+$modclear{"iter"} = "Range and value iterators";
+$modclear{"support"} = "Support algorithms and datastructures";
+$modclear{"example"} = "\%Example scripts";
+$modclear{"test"} = "Systematic tests";
+
+
+$catclear{"core"} = "Core functionality";
+$catclear{"var"} = "Variables, views, and variable implementations";
+$catclear{"prop"} = "Propagators";
+$catclear{"branch"} = "Branchings";
+$catclear{"search"} = "Search engines";
+$catclear{"post"} = "Posting propagators and branchings";
+$catclear{"any"} = "All";
+$catclear{"other"} = "Miscellaneous";
+$catclear{"int"} = "Finite domain integers";
+$catclear{"set"} = "Finite integer sets";
+$catclear{"cpltset"} =
+  "Finite integer sets with complete domain representation";
+$catclear{"minimodel"} = "Minimal modelling support";
+$catclear{"stress"} = "System stress";
+
+print <<EOF
+/**
+  \\page PageCodeStat Gecode code statistics
+
+The following approximate breakdown into the different parts of %Gecode
+gives some statistics about the amount of code and documentation 
+contained in the code (as comments) where blank lines are excluded. 
+
+The abbreviation "loc" means "lines of code" and "lod" means "lines of 
+documentation".
+
+EOF
+;
+
+
+$an_code    = 0;
+$an_comment = 0;
+$an_class   = 0;
+
+foreach $module (@modorder) {
+  print " - " . $modclear{$module} . ": ";
+  $mn_code    = 0;
+  $mn_comment = 0;
+  $mn_class   = 0;
+  $n_cat = 0;
+  $doc = "";
+  foreach $cat (@catorder) {
+    $k = "$module-$cat";
+    if ($code{$k}) {
+      $n_cat += 1;
+      $doc = $doc . "   - " . $catclear{$cat} . ": ";
+      $mn_code    += $code{$k};
+      $mn_comment += $comment{$k};
+      $mn_class   += $class{$k};
+      $doc = $doc .  $class{$k} . " classes, ";
+      $doc = $doc .  $code{$k} . " loc, ";
+      $doc = $doc .  $comment{$k} . " lod\n";
+    }
+  } 
+  print $mn_class . " classes, " . $mn_code . " loc, " . $mn_comment . " lod\n";
+  if ($n_cat > 1) {
+    print $doc;
+  }
+  $an_code    += $mn_code;
+  $an_comment += $mn_comment;
+  $an_class   += $mn_class;
+}
+
+
+print <<EOF
+
+The grand total: $an_class classes, $an_code loc, $an_comment lod
+
+*/
+EOF
+;
+			 

data/ext/gecode-2.1.1/misc/gentxtchangelog.perl

@@ -0,0 +1,192 @@
+#!/usr/bin/perl
+#
+#  Main authors:
+#     Christian Schulte <schulte@gecode.org>
+#     Guido Tack <tack@gecode.org>
+#
+#  Copyright:
+#     Christian Schulte, 2005
+#     Guido Tack, 2006
+#
+#  Last modified:
+#     $Date: 2007-11-27 15:41:56 +0100 (Tue, 27 Nov 2007) $ by $Author: tack $
+#     $Revision: 5459 $
+#
+#  This file is part of Gecode, the generic constraint
+#  development environment:
+#     http://www.gecode.org
+#
+#  Permission is hereby granted, free of charge, to any person obtaining
+#  a copy of this software and associated documentation files (the
+#  "Software"), to deal in the Software without restriction, including
+#  without limitation the rights to use, copy, modify, merge, publish,
+#  distribute, sublicense, and/or sell copies of the Software, and to
+#  permit persons to whom the Software is furnished to do so, subject to
+#  the following conditions:
+#
+#  The above copyright notice and this permission notice shall be
+#  included in all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+#
+
+print <<EOF
+Changelog for Gecode
+==============================================================================
+
+EOF
+;
+
+
+# 
+# Compile changelog
+#
+
+$first   = 1;
+$version = "";
+$info    = "";
+
+$modclear{"kernel"} = "Kernel";
+$modclear{"search"} = "Search engines";
+$modclear{"int"} = "Finite domain integers";
+$modclear{"set"} = "Finite integer sets";
+$modclear{"cpltset"} = "Finite integer sets with complete representation";
+$modclear{"minimodel"} = "Minimal modelling support";
+$modclear{"iter"} = "Range and value iterators";
+$modclear{"support"} = "Support algorithms and datastructures";
+$modclear{"example"} = "Example scripts";
+$modclear{"test"} = "Systematic tests";
+$modclear{"gist"} = "Gist";
+$modclear{"other"} = "General";
+
+$whatclear{"bug"} = "Bug fixes";
+$whatclear{"performance"} = "Performance improvements";
+$whatclear{"documentation"} = "Documentation fixes";
+$whatclear{"new"} = "Additions";
+$whatclear{"change"} = "Other changes";
+
+$rankclear{"minor"} = "minor";
+$rankclear{"major"} = "major";
+
+@modorder = ("kernel","search","int","set","clptset","minimodel",
+	     "iter","support","example","test","gist","other");
+
+@whatorder = ("new","change","bug","performance","documentation");
+
+foreach $mod (@modorder) {
+  $hastext{$mod} = 0;
+  foreach $what (@whatorder) {
+    $text{"$mod-$what"} = "";
+  }
+}
+
+while ($l = <>) {
+ LINE:
+  next if ($l =~ /^\#/);
+  $l =~ s/%Gecode/Gecode/g;
+  if ($l =~ /^\[RELEASE\]/) {
+    # Print previous
+    if (!$first) {
+      print "Changes in Version $version ($date)\n\n";
+
+      print "Scope:$info";
+
+      foreach $mod (@modorder) {
+	if ($hastext{$mod}) {
+	  print "- " . $modclear{$mod} . "\n";
+	  $hastext{$mod} = 0;
+	  foreach $what (@whatorder) {
+	    if (!($text{"$mod-$what"} eq "")) {
+	      print "  - " . $whatclear{$what} . "\n";
+	      print $text{"$mod-$what"};
+	      $text{"$mod-$what"} = "";
+	    }
+	  }
+
+	}
+      }
+      print "\n------------------------------------------------------------------------------\n\n";
+    }
+    $first   = 0;
+    $version = "";
+    $info    = "";
+    $date    = "";
+    while (($l = <>) && !($l =~ /\[DESCRIPTION\]/)) {
+      $l =~ s/%Gecode/Gecode/g;
+      if ($l =~ /Version:[\t ]*(.*)$/) {
+	$version = $1;
+      } elsif ($l =~ /Date:[\t ]*(.*)$/) {
+	$date    = $1;
+      }
+    }
+    while (($l = <>) && !($l =~ /\[ENTRY\]/)) {
+      $l =~ s/%Gecode/Gecode/g;
+#      chop $l;
+      $info = $info . " " . $l;
+    }
+    goto LINE;
+  }
+  if ($l =~ /^\[ENTRY\]/) {
+    my $mod, $what, $rank, $bug, $desc, $thanks;
+    $desc = "";
+    $bug = "";
+    $rank = "";
+    $what = "";
+    $mod = "";
+    $thanks = "";
+    while (($l = <>) && !($l =~ /\[DESCRIPTION\]/)) {
+      $l =~ s/%Gecode/Gecode/g;
+      if ($l =~ /Module:[\t ]*(.*)$/) {
+	$mod  = $1;
+      } elsif ($l =~ /What:[\t ]*(.*)$/) {
+	$what = $1;
+      } elsif ($l =~ /Rank:[\t ]*(.*)$/) {
+	$rank = $1;
+      } elsif ($l =~ /Bug:[\t ]*(.*)$/) {
+	$bug  = $1;
+      } elsif ($l =~ /Thanks:[\t ]*(.*)$/) {
+	$thanks  = $1;
+      }
+    }
+    
+    while (($l = <>) && 
+	   !(($l =~ /\[ENTRY\]/) || ($l =~ /\[RELEASE\]/))) {
+       $l =~ s/%Gecode/Gecode/g;
+#      chop $l;
+	if ($desc eq "") {
+	    $desc = $l;
+	} else {
+	    $desc = $desc . "      " . $l;
+	}
+    }
+    chop $desc;
+    $hastext{$mod} = 1;
+    $rb = $rankclear{$rank};
+    if (!($bug eq "")) {
+	$rb = $rb . ", bugzilla entry $bug";
+#      $rb = $rb . ", <a href=\"http://www.gecode.org/bugzilla/show_bug.cgi?id="
+#	. $bug . "\">bugzilla entry</a>";
+    }
+    if (!($thanks eq "")) {
+      $rb = $rb . ", thanks to $thanks";
+    }
+    $text{"$mod-$what"} = 
+      ($text{"$mod-$what"} . "    - $desc(" . $rb . ")\n");
+    goto LINE;
+  }
+}
+
+print <<EOF
+Initial release (2005-12-06)
+
+ No changes, of course.
+
+EOF
+;

data/ext/gecode-2.1.1/misc/genvariables.perl

@@ -0,0 +1,905 @@
+#!/usr/bin/perl
+#
+#  Main authors:
+#     Christian Schulte <schulte@gecode.org>
+#
+#  Copyright:
+#     Christian Schulte, 2007
+#
+#  Last modified:
+#     $Date: 2008-03-06 03:51:28 +0100 (Thu, 06 Mar 2008) $ by $Author: schulte $
+#     $Revision: 6432 $
+#
+#  This file is part of Gecode, the generic constraint
+#  development environment:
+#     http://www.gecode.org
+#
+#  Permission is hereby granted, free of charge, to any person obtaining
+#  a copy of this software and associated documentation files (the
+#  "Software"), to deal in the Software without restriction, including
+#  without limitation the rights to use, copy, modify, merge, publish,
+#  distribute, sublicense, and/or sell copies of the Software, and to
+#  permit persons to whom the Software is furnished to do so, subject to
+#  the following conditions:
+#
+#  The above copyright notice and this permission notice shall be
+#  included in all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+#
+
+use File::Basename;
+
+while (($arg = $ARGV[$i]) && ($arg =~ /^-/)) {
+  $i++;
+  if ($arg eq "-header") {
+    $gen_header = 1;
+  } elsif ($arg eq "-typeicc") {
+    $gen_typeicc   = 1;
+  } elsif ($arg eq "-typecc") {
+    $gen_typecc   = 1;
+  }
+}
+
+$varfile = $ARGV[$i];
+
+my ($filename, $directory, $suffix) = fileparse($varfile);
+
+open VARFILE, $varfile;
+
+$n_files = 0;
+while ($l = <VARFILE>) {
+  if ($l =~ /^File:\s*([^ \t\r\n]+)/io) {
+    $files[$n_files] = $1;
+    $n_files++;
+  }
+}
+close VARFILE;
+
+print <<EOF
+/*
+ *  CAUTION:
+ *    This file has been automatically generated. Do not edit,
+ *    edit the specification file "variable.vsl" and the following
+ *    files instead:
+EOF
+;
+
+for ($f=0; $f<$n_files; $f++) {
+  print " *     - $files[$f]\n";
+}
+
+print <<EOF
+ *
+ *  This file contains generated code fragments which are
+ *  copyrighted as follows:
+ *
+ *  Main author:
+ *     Christian Schulte <schulte\@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2007
+ *
+ *  The generated code fragments are part of Gecode, the generic
+ *  constraint development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+EOF
+;
+
+for ($f=0; $f<$n_files; $f++) {
+  open (FILE, $directory.$files[$f]) || die "Could not open ".$files[$f];
+
+  ## General values
+  $name[$f]    = "";
+  $vti[$f]     = "";
+  $ifdef[$f]   = "";
+  $endif[$f]   = "";
+  $dispose[$f] = 0;
+
+  ##
+  ## Headers and footers
+  ##
+  $mehdr[$f]  = ""; # Header text for modification events
+  $meftr[$f]  = ""; # Footer text for modification events
+
+  $pchdr[$f]  = ""; # Header text for propagation conditions
+  $pcftr[$f]  = ""; # Footer text for propagation conditions
+
+  ##
+  ## Real stuff
+  ##
+
+  # $mec[$f] : combination table
+  # $men[$f] : name table
+  # $meh[$f] : header table
+  $me_n[$f] = 0; # running number of modification events
+  $me_subscribe[$f] = "";
+
+  # $pcn[$f] : name table
+  # $pch[$f] : header table
+  $pc_n[$f] = 0; # running number of propagation conditions
+
+
+  $free_bits[$f] = 0;
+
+  while ($l = <FILE>) {
+  LINE:
+    next if ($l =~ /^\#/);
+    last if ($l =~ /^\[End\]/io);
+
+    if ($l =~ /^\[General\]/io) {
+      while (($l = <FILE>) && !($l =~ /^\[/)) {
+	next if ($l =~ /^\#/);
+	if ($l =~ /^Name:\s*(\w+)/io) {
+	  $name[$f] = $1;
+	  $vti[$f]  = uc($name[$f]);
+	} elsif ($l =~ /^Ifdef:\s*(\w+)/io) {
+	  $ifdef[$f] = "#ifdef $1\n";
+	  $endif[$f] = "#endif\n";
+	} elsif ($l =~ /^Dispose:\s*true/io) {
+	  $dispose[$f] = 1;
+	} elsif ($l =~ /^Namespace:\s*([^ \t\r\n]+)/io) {
+	  $namespace[$f] = $1;
+	} elsif ($l =~ /^Bits:\s*([^ \t\r\n]+)/io) {
+	  $free_bits[$f] = $1+0;
+	}
+      }
+      goto LINE;
+    } elsif ($l =~ /^\[ModEventHeader\]/io) {
+      while (($l = <FILE>) && !($l =~ /^\[/)) {
+	next if ($l =~ /^\#/);
+	$mehdr[$f] = $mehdr[$f] . $l;
+      }
+      goto LINE;
+    } elsif ($l =~ /^\[ModEvent\]/io) {
+      $n = "";
+      $h = "";
+
+      while (($l = <FILE>) && !($l =~ /^\[/)) {
+	next if ($l =~ /^\#/);
+	if ($l =~ /^Name:\s*(\w+)\s*=\s*(\w+)/io) {
+	  # Found a special modification event
+	  $lhs = $1; $rhs = $2;
+	  if (!($rhs eq "FAILED") && !($rhs eq "NONE") &&
+	      !($rhs eq "ASSIGNED") && !($rhs eq "SUBSCRIBE")) {
+	    die "Unknown special modification event: $rhs\n";
+	  }
+	  if ($rhs eq "SUBSCRIBE") {
+	    $me_subscribe[$f] = "ME_$vti[$f]_$lhs";
+	  } else {
+	    $mespecial{$f}{$lhs} = $rhs;
+	    if ($rhs eq "ASSIGNED") {
+	      $me_assigned[$f] = "ME_$vti[$f]_$lhs";
+	    } elsif ($rhs eq "FAILED") {
+	      $me_failed[$f] = "ME_$vti[$f]_$lhs";
+	    } els
+	  }
+	  $n = $lhs;
+	} elsif ($l =~ /^Name:\s*(\w+)/io) {
+	  # Found a normal modification event
+	  $n = $1;
+	} elsif ($l =~ /^Combine:\s*(.+)/io) {
+	  # Found combination information
+	  $combines = $1;
+	  while ($combines =~ /(\w+)\s*=(\w+)/g) {
+	    $mec{$f}{$n}{$1} = $2;
+	    $mec{$f}{$1}{$n} = $2;
+	  }
+	} else {
+	  $h = $h . $l;
+	}
+      }
+      $men[$f][$me_n[$f]] = $n;
+      $meh[$f][$me_n[$f]] = $h;
+      $me_n[$f]++;
+      $mec{$f}{"NONE"}{$n} = $n;
+      $mec{$f}{$n}{"NONE"} = $n;
+      goto LINE;
+    } elsif ($l =~ /^\[ModEventFooter\]/io) {
+      while (($l = <FILE>) && !($l =~ /^\[/)) {
+	next if ($l =~ /^\#/);
+	$meftr[$f] = $meftr[$f] . $l;
+      }
+      goto LINE;
+    } elsif ($l =~ /^\[PropCondHeader\]/io) {
+      while (($l = <FILE>) && !($l =~ /^\[/)) {
+	next if ($l =~ /^\#/);
+	$pchdr[$f] = $pchdr[$f] . $l;
+      }
+      goto LINE;
+    } elsif ($l =~ /^\[PropCond\]/io) {
+      $n = "";
+      $h = "";
+
+      while (($l = <FILE>) && !($l =~ /^\[/)) {
+	next if ($l =~ /^\#/);
+	if ($l =~ /^Name:\s*(\w+)\s*=\s*(\w+)/io) {
+	  # Found a special propagation condition
+	  $lhs = $1; $rhs = $2;
+	  if (!($rhs eq "ASSIGNED")) {
+	    die "Unknown special propagation condition: $rhs\n";
+	  }
+	  $pcspecial{$f}{$lhs} = $rhs;
+	  if ($rhs eq "ASSIGNED") {
+	    $pc_assigned[$f] = "PC_$vti[$f]_$lhs";
+	  }
+	  $n = $lhs;
+	} elsif ($l =~ /^Name:\s*(\w+)/io) {
+	  # Found a normal modification event
+	  $n = $1;
+	} elsif ($l =~ /^ModEvents:\s*(.+)/io) {
+	  # Found relation to modification events
+	  $events = $1;
+	  while ($events =~ /(\w+)/g) {
+	    $mepc{$f}{$1}{$n} = 1;
+	  }
+	} else {
+	  $h = $h . $l;
+	}
+      }
+      $pcn[$f][$pc_n[$f]] = $n;
+      $pch[$f][$pc_n[$f]] = $h;
+      $pc_n[$f]++;
+      goto LINE;
+    } elsif ($l =~ /^\[PropCondFooter\]/io) {
+      while (($l = <FILE>) && !($l =~ /^\[/)) {
+	next if ($l =~ /^\#/);
+	$pcftr[$f] = $pcftr[$f] . $l;
+      }
+      goto LINE;
+    }
+
+  }
+  close FILE;
+
+
+  $maxpc[$f] = "PC_$vti[$f]_" . $pcn[$f][$pc_n[$f]-1];
+  $class[$f] = "$name[$f]VarImpBase";
+  $conf[$f]  = "$name[$f]VarImpConf";
+  $base[$f]  = "Gecode::VarImp< $namespace[$f]::$conf[$f]>";
+  # Generate namespace header and footer
+  foreach $ns (split('::',$namespace[$f])) {
+    $hdr[$f] = "$hdr[$f]namespace $ns { ";
+    $ftr[$f] = "$ftr[$f]}";
+  }
+  $hdr[$f] = "$hdr[$f]\n";
+  $ftr[$f] = "$ftr[$f]\n";
+
+  ## Check whether there is only one real event
+  if ($me_n[$f] == 3) {
+    $me_subscribe[$f] = $me_assigned[$f];
+  }
+
+  $o = 2;
+  for ($i=0; $i<$me_n[$f]; $i++) {
+    $n = $men[$f][$i];
+    if ($mespecial{$f}{$n} eq "NONE") {
+      $val2me[$f][0] = $n;
+    } elsif ($mespecial{$f}{$n} eq "ASSIGNED") {
+      $val2me[$f][1] = $n;
+    } elsif (!$mespecial{$f}{$n}) {
+      $val2me[$f][$o] = $n; $o++;
+    }
+  }
+  $me_max[$f]   = "ME_$vti[$f]_" . $val2me[$f][$o-1] . "+1";
+  $me_max_n[$f] = $o;
+
+  $len = 0;
+  for ($i=0; $i<$me_max_n[$f];$i++) {
+    $n = $val2me[$f][$i];
+    $me_a{$f}{$n} = "ME_$vti[$f]_$n";
+    if (length($me_a{$f}{$n}) > $len) {
+      $len = length($me_a{$f}{$n});
+    }
+  }
+  for ($i=0; $i<$me_max_n[$f]; $i++) {
+    $n = $val2me[$f][$i];
+    while ($len > length($me_a{$f}{$n})) {
+      $me_a{$f}{$n} = "$me_a{$f}{$n} ";
+    }
+  }
+
+  for ($b=1; (1 << $b) < $me_max_n[$f]; $b++) {}
+  $bits[$f] = $b;
+}
+
+if ($gen_typeicc) {
+  for ($f = 0; $f<$n_files; $f++) {
+    print $ifdef[$f];
+    print $hdr[$f];
+    print $mehdr[$f];
+    $o = 1;
+    for ($i=0; $i<$me_n[$f]; $i++) {
+      $n = $men[$f][$i];
+      print $meh[$f][$i];
+      print "  const Gecode::ModEvent ME_" . $vti[$f] . "_${n} = ";
+      if ($mespecial{$f}{$n}) {
+	print "Gecode::ME_GEN_" . $mespecial{$f}{$n};
+      } else {
+	print "Gecode::ME_GEN_ASSIGNED + " . $o;
+	$o++;
+      }
+      print ";\n";
+    }
+
+    print $meftr[$f];
+    print $pchdr[$f];
+
+    print "  /// Propagation condition to be ignored (convenience)\n";
+    print "  const Gecode::PropCond PC_$vti[$f]_NONE = Gecode::PC_GEN_NONE;\n";
+    $o = 1;
+    for ($i=0; $i<$pc_n[$f]; $i++) {
+      $n = $pcn[$f][$i];
+      print $pch[$f][$i];
+      print "  const Gecode::PropCond PC_$vti[$f]_${n} = ";
+      if ($pcspecial{$f}{$n}) {
+	$pc_assigned[$f] = "PC_$vti[$f]_${n}";
+	print "Gecode::PC_GEN_" . $pcspecial{$f}{$n};
+      } else {
+	print "Gecode::PC_GEN_ASSIGNED + " . $o;
+	$o++;
+      }
+      print ";\n";
+    }
+    print $pcftr[$f];
+    print $ftr[$f];
+    print $endif[$f];
+  }
+
+
+  for ($f = 0; $f<$n_files; $f++) {
+    print $ifdef[$f];
+    if ($dispose[$f]) {
+      print "\n#ifndef GECODE_HAS_VAR_DISPOSE\n";
+      print "#define GECODE_HAS_VAR_DISPOSE 1\n";
+      print "#endif\n\n";
+    }
+    print $hdr[$f];
+    print "  /// Configuration for $name[$f]-variable implementations\n";
+    print "  class $conf[$f] {\n";
+    print "  public:\n";
+    print "    /// Index for cloning\n";
+    print "    static const int idx_c = ";
+    if ($f == 0) {
+      print "0;\n";
+    } else {
+      print "$namespace[$f-1]::$conf[$f-1]::idx_c+1;\n";
+    }
+    print "    /// Index for disposal\n";
+    print "    static const int idx_d = ";
+    if ($dispose[$f]) {
+      if ($f == 0) {
+	print "0;\n";
+      } else {
+	print "$namespace[$f-1]::$conf[$f-1]::idx_d+1;\n";
+      }
+    } else {
+      if ($f == 0) {
+	print "-1;\n";
+      } else {
+	print "$namespace[$f-1]::$conf[$f-1]::idx_d;\n";
+      }
+    }
+    print "    /// Maximal propagation condition\n";
+    print "    static const Gecode::PropCond pc_max = $maxpc[$f];\n";
+    print "    /// Freely available bits\n";
+    print "    static const int free_bits = $free_bits[$f];\n";
+    print "    /// Start of bits for modification event delta\n";
+    print "    static const int med_fst = ";
+    if ($f == 0) {
+      print "0;\n";
+    } else {
+      print "$namespace[$f-1]::$conf[$f-1]::med_lst;\n";
+    }
+    print "    /// End of bits for modification event delta\n";
+    print "    static const int med_lst = med_fst + $bits[$f];\n";
+    print "    /// Bitmask for modification event delta\n";
+    print "    static const int med_mask = ((1 << $bits[$f]) - 1) << med_fst;\n";
+    print "    /// Combine modification events \\a me1 and \\a me2\n";
+    print "    static Gecode::ModEvent me_combine(Gecode::ModEvent me1, Gecode::ModEvent me2);\n";
+    print "    /// Update modification even delta \\a med by \\a me, return true on change\n";
+    print "    static bool med_update(Gecode::ModEventDelta& med, Gecode::ModEvent me);\n";
+    print "    /// Variable type identifier for reflection\n";
+    print "    static GECODE_KERNEL_EXPORT const Gecode::Support::Symbol vti;\n";
+    print "  };\n";
+    print $ftr[$f];
+    if (!($ifdef[$f] eq "")) {
+      print "#else\n";
+      print $hdr[$f];
+      print "  /// Dummy configuration for $name[$f]-variable implementations\n";
+      print "  class $conf[$f] {\n";
+      print "  public:\n";
+      print "    /// Index for cloning\n";
+      print "    static const int idx_c = ";
+      if ($f == 0) {
+	print "-1;\n";
+      } else {
+	print "$namespace[$f-1]::$conf[$f-1]::idx_c;\n";
+      }
+      print "    /// Index for disposal\n";
+      print "    static const int idx_d = ";
+      if ($f == 0) {
+	print "-1;\n";
+      } else {
+	print "$namespace[$f-1]::$conf[$f-1]::idx_d;\n";
+      }
+      print "    /// End of bits for modification event delta\n";
+      print "    static const int med_lst = ";
+      if ($f == 0) {
+	print "0;\n";
+      } else {
+	print "$namespace[$f-1]::$conf[$f-1]::med_lst;\n";
+      }
+      print "  };\n";
+      print $ftr[$f];
+    }
+    print $endif[$f];
+  }
+  print "\n";
+  print "namespace Gecode {\n\n";
+  print "  /// Configuration for all variable implementations\n";
+  print "  class AllVarConf {\n";
+  print "  public:\n";
+  print "    /// Index for cloning\n";
+  print "    static const int idx_c = $namespace[$n_files-1]::$conf[$n_files-1]::idx_c+1;\n";
+  print "    /// Index for dispose\n";
+  print "    static const int idx_d = $namespace[$n_files-1]::$conf[$n_files-1]::idx_d+1;\n";
+  print "    /// Combine modification event delta \\a med1 with \\a med2\n";
+  print "    static ModEventDelta med_combine(ModEventDelta med1, ModEventDelta med2);\n";
+  print "  };\n\n}\n\n";
+  for ($f = 0; $f<$n_files; $f++) {
+    print $ifdef[$f];
+    print $hdr[$f];
+    print "  forceinline Gecode::ModEvent\n";
+    print "  $conf[$f]::me_combine(Gecode::ModEvent me1, Gecode::ModEvent me2) {\n";
+
+    if ($me_max_n[$f] == 2) {
+      print "    return me1 | me2;\n";
+    } elsif ($me_max_n[$f] <= 4) {
+      print "    static const Gecode::ModEvent me_c = (\n";
+
+      for ($i=0; $i<$me_max_n[$f];$i++) {
+	$n1 = $val2me[$f][$i];
+	print "      (\n";
+	for ($j=0; $j<$me_max_n[$f];$j++) {
+	  $n2 = $val2me[$f][$j];
+	  $n3 = $mec{$f}{$n1}{$n2};
+	  $shift = (($i << 3) + ($j << 1));
+	  if ($shift < 10) {
+	    $shift = " $shift";
+	  }
+	  print "        ($me_a{$f}{$n3} << $shift)";
+	  if ($j+1 == $me_max_n[$f]) {
+	    print "   ";
+	  } else {
+	    print " | ";
+	  }
+	  print " // [$me_a{$f}{$n1}][$me_a{$f}{$n2}]\n";
+	}
+	if ($i+1 == $me_max_n[$f]) {
+	  print "      )\n";
+	} else {
+	  print "      ) |\n";
+	}
+      }
+      print "    );\n";
+      print "    return ((me_c >> (me2 << 3)) >> (me1 << 1)) & 3;\n";
+    } else {
+      print "    static const Gecode::ModEvent me_c[$me_max[$f]][$me_max[$f]] = {\n";
+      for ($i=0; $i<$me_max_n[$f];$i++) {
+	$n1 = $val2me[$f][$i];
+	print "      {\n";
+	for ($j=0; $j<$me_max_n[$f];$j++) {
+	  $n2 = $val2me[$f][$j];
+	  $n3 = $mec{$f}{$n1}{$n2};
+	  print "        $me_a{$f}{$n3}";
+	  if ($j+1 == $me_max_n[$f]) {
+	    print " ";
+	  } else {
+	    print ",";
+	  }
+	  print " // [$me_a{$f}{$n1}][$me_a{$f}{$n2}]\n";
+	}
+	print "      }";
+	if ($i+1 == $me_max_n[$f]) {
+	  print "\n";
+	} else {
+	  print ",\n";
+	}
+      }
+      print "    };\n";
+      print "    return me_c[me1][me2];\n";
+    }
+    print "  }\n";
+    print "  forceinline bool\n";
+    print "  $conf[$f]::med_update(Gecode::ModEventDelta& med, Gecode::ModEvent me) {\n";
+
+    print "    switch (me) {\n";
+    if ($me_max_n[$f] == 2) {
+      $ME_NONE = "ME_$vti[$f]_NONE";
+      if ($val2me[$f][0] eq "NONE") {
+        $ME_ASSIGNED = "ME_$vti[$f]_$val2me[$f][1]";
+      } else {
+        $ME_ASSIGNED = "ME_$vti[$f]_$val2me[$f][0]";
+      }
+      print "    case $ME_NONE:\n";
+      print "      return false;\n";
+      print "    case $ME_ASSIGNED:\n";
+      print "      if ((med & ($ME_ASSIGNED << med_fst)) != 0)\n";
+      print "        return false;\n";
+      print "      med |= $ME_ASSIGNED << med_fst;\n";
+      print "      break;\n";
+    } else {
+      $lvti = lc($vti[$f]);
+      for ($i=0; $i<$me_max_n[$f];$i++) {
+	$n1 = $val2me[$f][$i];
+	$weak = 1;
+	for ($j=0; $j<$me_max_n[$f];$j++) {
+	  $n2 = $val2me[$f][$j];
+	  if (!($n2 eq "NONE") && !($n2 eq $n1) &&
+	      !($mec{$f}{$n1}{$n2} eq $n2)) {
+	    $weak = 0;
+	  }
+	}
+        print "    case ME_$vti[$f]_$n1:\n";
+        if ($n1 eq "NONE") {
+          print "      return false;\n";
+        } elsif ($mespecial{$f}{$n1} eq "ASSIGNED") {
+          print "      {\n";
+          print "        Gecode::ModEventDelta med_$lvti = med & med_mask;\n";
+          print "        if (med_$lvti == (ME_$vti[$f]_$n1 << med_fst))\n";
+          print "          return false;\n";
+          print "        med ^= med_$lvti;\n";
+          print "        med ^= ME_$vti[$f]_$n1 << med_fst;\n";
+          print "        break;\n";
+          print "      }\n";
+	} elsif ($weak) {
+          print "      {\n";
+          print "        Gecode::ModEventDelta med_$lvti = med & med_mask;\n";
+          print "        if (med_$lvti != 0)\n";
+          print "          return false;\n";
+          print "        med |= ME_$vti[$f]_$n1 << med_fst;\n";
+          print "        break;\n";
+          print "      }\n";
+	} else {
+          print "      {\n";
+          if ($me_max_n[$f] <= 8) {
+            print "        static const Gecode::ModEvent me_c = (\n";
+	    for ($j=0; $j<$me_max_n[$f];$j++) {
+	      $n2 = $val2me[$f][$j];
+	      $n3 = $mec{$f}{$n1}{$n2};
+              $shift = $j << 2;
+	      if ($shift < 10) {
+                $shift = " $shift";
+              }
+	      print "          (($me_a{$f}{$n2} ^ $me_a{$f}{$n3}) << $shift)";
+	      if ($j+1 != $me_max_n[$f]) {
+	        print " |\n";
+	      }
+	    }
+            print "\n        );\n";
+            print "        Gecode::ModEvent me_o = (med & med_mask) >> med_fst;\n";
+            print "        Gecode::ModEvent me_n = (me_c >> (me_o << 2)) & med_mask;\n";
+            print "        if (me_n == 0)\n";
+            print "          return false;\n";
+            print "        med ^= me_n << med_fst;\n";
+            print "        break;\n";
+          } else {
+            print "        static const Gecode::ModEventDelta me_c[$me_max[$f]] = {\n";
+	    for ($j=0; $j<$me_max_n[$f];$j++) {
+	      $n2 = $val2me[$f][$j];
+	      $n3 = $mec{$f}{$n1}{$n2};
+	      print "          ($me_a{$f}{$n2} ^ $me_a{$f}{$n3}) << med_fst";
+	      if ($j+1 != $me_max_n[$f]) {
+	        print ",\n";
+	      }
+	    }
+            print "\n        };\n";
+            print "        Gecode::ModEvent me_o = (med & med_mask) >> med_fst;\n";
+            print "        Gecode::ModEventDelta med_n = me_c[me_o];\n";
+            print "        if (med_n == 0)\n";
+            print "          return false;\n";
+            print "        med ^= med_n;\n";
+            print "        break;\n";
+          }
+          print "      }\n";
+        }
+      }
+    }
+    print "    default: GECODE_NEVER;\n";
+    print "    }\n";
+    print "    return true;\n";
+    print "  }\n\n";
+    print $ftr[$f];
+    print $endif[$f];
+  }
+  print "namespace Gecode {\n";
+  print "  forceinline ModEventDelta\n";
+  print "  AllVarConf::med_combine(ModEventDelta med1, ModEventDelta med2) {\n";
+  for ($f = 0; $f<$n_files; $f++) {
+    $vic = "$namespace[$f]::$conf[$f]";
+    print $ifdef[$f];
+    print "    (void) ${vic}::med_update(med1,(med2 & ${vic}::med_mask) >> ${vic}::med_fst);\n";
+    print $endif[$f];
+  }
+  print "    return med1;\n";
+  print "  }\n}\n\n";
+}
+
+if ($gen_typecc) {
+  print "#include \"gecode/kernel.hh\"\n";
+  print "\n";
+  for ($f = 0; $f<$n_files; $f++) {
+    print $ifdef[$f];
+    print $hdr[$f];
+    print "  const Gecode::Support::Symbol $conf[$f]::vti = \"$name[$f]\";\n";
+    print $ftr[$f];
+    print $endif[$f];
+  }
+  print "\n";
+}
+
+if ($gen_header) {
+  for ($f = 0; $f<$n_files; $f++) {
+    print $ifdef[$f];
+    print $hdr[$f];
+    print "  /// Base-class for $name[$f]-variable implementations\n";
+    print "  class $class[$f] : public $base[$f] {\n";
+    if ($dispose[$f]) {
+      print <<EOF
+  private:
+    /// Link to next variable, used for disposal
+    $class[$f]* _next_d;
+EOF
+;
+  }
+
+  print <<EOF
+  protected:
+    /// Constructor for cloning \\a x
+    $class[$f](Gecode::Space* home, bool share, $class[$f]\& x);
+  public:
+    /// Constructor for creating static instance of variable
+    $class[$f](void);
+    /// Constructor for creating variable
+    $class[$f](Gecode::Space* home);
+    /// \\name Dependencies
+    //\@{
+    /** \\brief Subscribe propagator \\a p with propagation condition \\a pc
+     *
+     * In case \\a schedule is false, the propagator is just subscribed but
+     * not scheduled for execution (this must be used when creating
+     * subscriptions during propagation).
+     *
+     * In case the variable is assigned (that is, \\a assigned is
+     * true), the subscribing propagator is scheduled for execution.
+     * Otherwise, the propagator subscribes and is scheduled for execution
+     * with modification event \\a me provided that \\a pc is different
+     * from \\a $pc_assigned[$f].
+     */
+    void subscribe(Gecode::Space* home, Gecode::Propagator* p, Gecode::PropCond pc, bool assigned, bool schedule);
+    /// Subscribe advisor \\a a if \\a assigned is false.
+    void subscribe(Gecode::Space* home, Gecode::Advisor* a, bool assigned);
+    /// Notify that variable implementation has been modified with modification event \\a me and delta information \\a d
+    Gecode::ModEvent notify(Gecode::Space* home, Gecode::ModEvent me, Gecode::Delta* d);
+    //\@}
+EOF
+;
+
+  if ($dispose[$f]) {
+  print <<EOF
+    /// Return link to next variable to be disposed
+    $class[$f]* next_d(void) const;
+EOF
+;
+  }
+
+  print <<EOF
+  };
+EOF
+;
+
+  print $ftr[$f];
+  print $endif[$f];
+
+
+}
+
+  for ($f = 0; $f<$n_files; $f++) {
+    print $ifdef[$f];
+    print $hdr[$f];
+
+if ($dispose[$f]) {
+  print <<EOF
+
+  forceinline
+  $class[$f]::$class[$f](void) {}
+
+  forceinline
+  $class[$f]::$class[$f](Gecode::Space* home)
+    : $base[$f](home) {
+     _next_d = static_cast<$class[$f]*>(vars_d(home)); vars_d(home,this);
+  }
+
+  forceinline
+  $class[$f]::$class[$f](Gecode::Space* home, bool share, $class[$f]\& x)
+    : $base[$f](home,share,x) {
+     _next_d = static_cast<$class[$f]*>(vars_d(home)); vars_d(home,this);
+  }
+
+  forceinline $class[$f]*
+  $class[$f]::next_d(void) const {
+    return _next_d;
+  }
+
+EOF
+;
+} else {
+  print <<EOF
+
+  forceinline
+  $class[$f]::$class[$f](void) {}
+
+  forceinline
+  $class[$f]::$class[$f](Gecode::Space* home)
+    : $base[$f](home) {}
+
+  forceinline
+  $class[$f]::$class[$f](Gecode::Space* home, bool share, $class[$f]\& x)
+    : $base[$f](home,share,x) {}
+EOF
+;
+}
+  print <<EOF
+
+  forceinline void
+  $class[$f]::subscribe(Gecode::Space* home, Gecode::Propagator* p, Gecode::PropCond pc, bool assigned, bool schedule) {
+    $base[$f]::subscribe(home,p,pc,assigned,$me_subscribe[$f],schedule);
+  }
+  forceinline void
+  $class[$f]::subscribe(Gecode::Space* home, Gecode::Advisor* a, bool assigned) {
+    $base[$f]::subscribe(home,a,assigned);
+  }
+
+EOF
+;
+
+if ($me_max_n[$f] == 2) {
+  print <<EOF
+  forceinline Gecode::ModEvent
+  $class[$f]::notify(Gecode::Space* home, Gecode::ModEvent, Gecode::Delta* d) {
+    schedule(home,$pc_assigned[$f],$pc_assigned[$f],$me_assigned[$f]);
+    if (!$base[$f]::advise(home,$me_assigned[$f],d))
+      return $me_failed[$f];
+    cancel(home);
+    return $me_assigned[$f];
+  }
+
+EOF
+;
+} else {
+  print <<EOF
+  forceinline Gecode::ModEvent
+  $class[$f]::notify(Gecode::Space* home, Gecode::ModEvent me, Gecode::Delta* d) {
+    switch (me) {
+EOF
+;
+
+  for ($i=0; $i<$pc_n[$f]; $i++) {
+     if ($pcspecial{$f}{$pcn[$f][$i]} eq "ASSIGNED") {
+       $val2pc[$f][0] = $pcn[$f][$i];
+     }
+  }
+  $o = 1;
+  for ($i=0; $i<$pc_n[$f]; $i++) {
+     if (!($pcspecial{$f}{$pcn[$f][$i]} eq "ASSIGNED")) {
+       $val2pc[$f][$o] = $pcn[$f][$i]; $o++;
+     }
+  }
+
+  for ($i=0; $i<$me_n[$f]; $i++) {
+    $n = $men[$f][$i];
+    if (!($mespecial{$f}{$n} eq "NONE") && !($mespecial{$f}{$n} eq "FAILED")) {
+      print "    case ME_$vti[$f]_$n:\n";
+      print "      // Conditions: ";
+      $fst = 1;
+      for ($j=0; $j<$pc_n[$f]; $j++) {
+        if ($mepc{$f}{$men[$f][$i]}{$pcn[$f][$j]}) {
+          if ($fst) {
+            $fst = 0;
+          } else {
+            print ", ";
+          }
+          print $pcn[$f][$j];
+        }
+      }
+      print "\n";
+      for ($j=0; $j<$pc_n[$f]; $j++) {
+	if ($mepc{$f}{$men[$f][$i]}{$val2pc[$f][$j]}) {
+	  # Found initial entry (plus one for stopping)
+	  print "      schedule(home,PC_$vti[$f]_" . $val2pc[$f][$j] . ",";
+	  # Look for all connected entries
+	  while ($mepc{$f}{$men[$f][$i]}{$val2pc[$f][$j+1]}) {
+	    $j++;
+          }
+	  # Found last entry
+	  print "PC_$vti[$f]_" . $val2pc[$f][$j] . ",ME_$vti[$f]_$n);\n";
+	}
+      }
+      print "      if (!$base[$f]::advise(home,ME_$vti[$f]_$n,d))\n";
+      print "        return $me_failed[$f];\n";
+      if ($mespecial{$f}{$n} eq "ASSIGNED") {
+        print "      cancel(home);\n";
+      }
+      print "      break;\n";
+    }
+  }
+
+
+  print <<EOF
+    default: GECODE_NEVER;
+    }
+    return me;
+  }
+
+EOF
+;
+}
+  print $ftr[$f];
+  print $endif[$f];
+}
+
+    print <<EOF
+namespace Gecode {
+
+  forceinline void
+  Space::update(ActorLink** sub) {
+EOF
+;
+
+  for ($f = 0; $f<$n_files; $f++) {
+    print $ifdef[$f];
+    print "    $base[$f]::update(this,sub);\n";
+    print $endif[$f];
+  }
+
+  print <<EOF
+  }
+}
+EOF
+;
+
+
+
+}
+
+print "// STATISTICS: kernel-var\n";