Commits

shl...@7081e830-ea04-0410-ae62-fb6148e2d9db  committed 8c0798d

CMake-ified and cleaned up p9_slice.

  • Participants
  • Parent commits 680a6a7
  • Branches conversion-to-cmake

Comments (0)

Files changed (4)

File src/wml_backend/p9_slice/CMakeLists.txt

+SET(CMAKE_VERBOSE_MAKEFILE ON)
+include("../../Common.cmake")
+
+PREPROCESS_PATH_PERL("slice_main.pl" "slice")
+RUN_POD2MAN("slice.pod" "slice.1" "1" "EN Tools" "EN Tools")

File src/wml_backend/p9_slice/SliceTerm.pm

+# @(#)yaccpar 1.8 (Berkeley) 01/20/91 (JAKE-P5BP-0.6 04/26/98)
+package SliceTermParser;
+;##
+;##  slice_term.y -- YACC parser for slice terms
+;##  Copyright (c) 1997-2002 Ralf S. Engelschall. 
+;##  Copyright (c) 1999-2002 Denis Barbier.
+;##
+
+package SliceTermParser;
+$SLICE=257;
+$YYERRCODE=256;
+@yylhs = (                                               -1,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,
+);
+@yylen = (                                                2,
+    1,    2,    2,    2,    3,    3,    3,    3,    3,    3,
+    3,    3,    3,
+);
+@yydefred = (                                             0,
+    0,    0,    0,    0,    0,    2,    3,    4,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,   13,    0,    0,
+    0,    0,    0,    0,    9,   10,
+);
+@yydgoto = (                                              5,
+);
+@yysindex = (                                           -33,
+  -60,  -33,  -33,  -33,   -7,    0,    0,    0,  -12,  -33,
+  -33,  -33,  -33,  -33,  -33,  -33,  -33,    0,  -31,  -31,
+   24,   24,  -36,  -36,    0,    0,
+);
+@yyrindex = (                                             0,
+    2,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,   15,   17,
+    9,   14,    3,    8,    0,    0,
+);
+@yygindex = (                                           135,
+);
+$YYTABLESIZE=224;
+@yytable = (                                              2,
+   17,    1,    5,    6,    0,   17,    4,    6,   11,    0,
+    0,   13,    0,   12,    7,    0,    8,    0,    0,    0,
+    0,    0,    0,    0,   17,    0,    0,    0,   18,   17,
+   13,    0,   11,    0,    0,   13,    0,   11,    1,    0,
+    0,    0,    1,    5,    1,    5,    1,    5,    6,   11,
+    6,   11,    6,   11,   12,    7,   12,    8,   12,    7,
+   17,    8,   15,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   16,    0,    0,    0,    0,   16,   10,
+    0,   15,    0,    0,   10,   12,   15,    0,   14,    0,
+    0,    0,    3,    1,    5,    1,    5,   16,    0,    6,
+   11,    6,   16,    0,   12,   12,    7,   14,    8,   12,
+    0,    1,   14,    0,    0,    0,    0,   15,    1,    5,
+    0,    1,    5,    0,    6,   11,    0,    6,    0,    0,
+   12,    0,    0,   16,    0,    0,    7,    8,    9,    0,
+    0,    0,    0,   14,   19,   20,   21,   22,   23,   24,
+   25,   26,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    1,
+);
+@yycheck = (                                             33,
+   37,    0,    0,   64,   -1,   37,   40,    0,    0,   -1,
+   -1,   43,   -1,    0,    0,   -1,    0,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   37,   -1,   -1,   -1,   41,   37,
+   43,   -1,   45,   -1,   -1,   43,   -1,   45,   37,   -1,
+   -1,   -1,   41,   41,   43,   43,   45,   45,   41,   41,
+   43,   43,   45,   45,   41,   41,   43,   41,   45,   45,
+   37,   45,   94,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  110,   -1,   -1,   -1,   -1,  110,   92,
+   -1,   94,   -1,   -1,   92,  117,   94,   -1,  120,   -1,
+   -1,   -1,  126,   92,   92,   94,   94,  110,   -1,   92,
+   92,   94,  110,   -1,  117,   92,   92,  120,   92,  117,
+   -1,  110,  120,   -1,   -1,   -1,   -1,   94,  117,  117,
+   -1,  120,  120,   -1,  117,  117,   -1,  120,   -1,   -1,
+  117,   -1,   -1,  110,   -1,   -1,    2,    3,    4,   -1,
+   -1,   -1,   -1,  120,   10,   11,   12,   13,   14,   15,
+   16,   17,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  257,
+);
+$YYFINAL=5;
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+$YYMAXTOKEN=257;
+#if YYDEBUG
+@yyname = (
+"end-of-file",'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
+"'!'",'','','',"'%'",'','',"'('","')'",'',"'+'",'',"'-'",'','','','','','','','','','','','','','','',
+'','','',"'\@'",'','','','','','','','','','','','','','','','','','','','','','','','','','','',"'\\\\'",'',
+"'^'",'','','','','','','','','','','','','','','',"'n'",'','','','','','',"'u'",'','',"'x'",'','','','','',
+"'~'",'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
+'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
+'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
+'','','','','','','','','','','','','',"SLICE",
+);
+@yyrule = (
+"\$accept : expr",
+"expr : SLICE",
+"expr : SLICE '\@'",
+"expr : '!' expr",
+"expr : '~' expr",
+"expr : expr 'x' expr",
+"expr : expr '^' expr",
+"expr : expr '\\\\' expr",
+"expr : expr '-' expr",
+"expr : expr 'n' expr",
+"expr : expr '%' expr",
+"expr : expr 'u' expr",
+"expr : expr '+' expr",
+"expr : '(' expr ')'",
+);
+#endif
+sub yyclearin {
+  my  $p;
+  ($p) = @_;
+  $p->{yychar} = -1;
+}
+sub yyerrok {
+  my  $p;
+  ($p) = @_;
+  $p->{yyerrflag} = 0;
+}
+sub new {
+  my $p = bless {}, $_[0];
+  $p->{yylex} = $_[1];
+  $p->{yyerror} = $_[2];
+  $p->{yydebug} = $_[3];
+  return $p;
+}
+sub YYERROR {
+  my  $p;
+  ($p) = @_;
+  ++$p->{yynerrs};
+  $p->yy_err_recover;
+}
+sub yy_err_recover {
+  my  $p;
+  ($p) = @_;
+  if ($p->{yyerrflag} < 3)
+  {
+    $p->{yyerrflag} = 3;
+    while (1)
+    {
+      if (($p->{yyn} = $yysindex[$p->{yyss}->[$p->{yyssp}]]) && 
+          ($p->{yyn} += $YYERRCODE) >= 0 && 
+          $p->{yyn} <= $#yycheck &&
+          $yycheck[$p->{yyn}] == $YYERRCODE)
+      {
+        warn("yydebug: state " . 
+                     $p->{yyss}->[$p->{yyssp}] . 
+                     ", error recovery shifting to state" . 
+                     $yytable[$p->{yyn}] . "\n") 
+                       if $p->{yydebug};
+        $p->{yyss}->[++$p->{yyssp}] = 
+          $p->{yystate} = $yytable[$p->{yyn}];
+        $p->{yyvs}->[++$p->{yyvsp}] = $p->{yylval};
+        next yyloop;
+      }
+      else
+      {
+        warn("yydebug: error recovery discarding state ".
+              $p->{yyss}->[$p->{yyssp}]. "\n") 
+                if $p->{yydebug};
+        return(undef) if $p->{yyssp} <= 0;
+        --$p->{yyssp};
+        --$p->{yyvsp};
+      }
+    }
+  }
+  else
+  {
+    return (undef) if $p->{yychar} == 0;
+    if ($p->{yydebug})
+    {
+      $p->{yys} = '';
+      if ($p->{yychar} <= $YYMAXTOKEN) { $p->{yys} = 
+        $yyname[$p->{yychar}]; }
+      if (!$p->{yys}) { $p->{yys} = 'illegal-symbol'; }
+      warn("yydebug: state " . $p->{yystate} . 
+                   ", error recovery discards " . 
+                   "token " . $p->{yychar} . "(" . 
+                   $p->{yys} . ")\n");
+    }
+    $p->{yychar} = -1;
+    next yyloop;
+  }
+0;
+} # yy_err_recover
+
+sub yyparse {
+  my  $p;
+  my $s;
+  ($p, $s) = @_;
+  if ($p->{yys} = $ENV{'YYDEBUG'})
+  {
+    $p->{yydebug} = int($1) if $p->{yys} =~ /^(\d)/;
+  }
+
+  $p->{yynerrs} = 0;
+  $p->{yyerrflag} = 0;
+  $p->{yychar} = (-1);
+
+  $p->{yyssp} = 0;
+  $p->{yyvsp} = 0;
+  $p->{yyss}->[$p->{yyssp}] = $p->{yystate} = 0;
+
+yyloop: while(1)
+  {
+    yyreduce: {
+      last yyreduce if ($p->{yyn} = $yydefred[$p->{yystate}]);
+      if ($p->{yychar} < 0)
+      {
+        if ((($p->{yychar}, $p->{yylval}) = 
+            &{$p->{yylex}}($s)) < 0) { $p->{yychar} = 0; }
+        if ($p->{yydebug})
+        {
+          $p->{yys} = '';
+          if ($p->{yychar} <= $#yyname) 
+             { $p->{yys} = $yyname[$p->{yychar}]; }
+          if (!$p->{yys}) { $p->{yys} = 'illegal-symbol'; };
+          warn("yydebug: state " . $p->{yystate} . 
+                       ", reading " . $p->{yychar} . " (" . 
+                       $p->{yys} . ")\n");
+        }
+      }
+      if (($p->{yyn} = $yysindex[$p->{yystate}]) && 
+          ($p->{yyn} += $p->{yychar}) >= 0 && 
+          $p->{yyn} <= $#yycheck &&
+          $yycheck[$p->{yyn}] == $p->{yychar})
+      {
+        warn("yydebug: state " . $p->{yystate} . 
+                     ", shifting to state " .
+              $yytable[$p->{yyn}] . "\n") if $p->{yydebug};
+        $p->{yyss}->[++$p->{yyssp}] = $p->{yystate} = 
+          $yytable[$p->{yyn}];
+        $p->{yyvs}->[++$p->{yyvsp}] = $p->{yylval};
+        $p->{yychar} = (-1);
+        --$p->{yyerrflag} if $p->{yyerrflag} > 0;
+        next yyloop;
+      }
+      if (($p->{yyn} = $yyrindex[$p->{yystate}]) && 
+          ($p->{yyn} += $p->{'yychar'}) >= 0 &&
+          $p->{yyn} <= $#yycheck &&
+          $yycheck[$p->{yyn}] == $p->{yychar})
+      {
+        $p->{yyn} = $yytable[$p->{yyn}];
+        last yyreduce;
+      }
+      if (! $p->{yyerrflag}) {
+        &{$p->{yyerror}}('syntax error', $s);
+        ++$p->{yynerrs};
+      }
+      return(undef) if $p->yy_err_recover;
+    } # yyreduce
+    warn("yydebug: state " . $p->{yystate} . 
+                 ", reducing by rule " . 
+                 $p->{yyn} . " (" . $yyrule[$p->{yyn}] . 
+                 ")\n") if $p->{yydebug};
+    $p->{yym} = $yylen[$p->{yyn}];
+    $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}+1-$p->{yym}];
+if ($p->{yyn} == 1) {
+{ $p->{yyval} = newvar($p->{yyvs}->[$p->{yyvsp}-0]); push(@OUT, "my ".$p->{yyval}." = \$CFG->{SLICE}->{SET}->{OBJ}->{'".$p->{yyvs}->[$p->{yyvsp}-0]."'}->Clone;"); }
+}
+if ($p->{yyn} == 2) {
+{ $p->{yyval} = newvar($p->{yyvs}->[$p->{yyvsp}-1]); push(@OUT, "my ".$p->{yyval}." = \$CFG->{SLICE}->{SET}->{OBJ}->{'NOV_".$p->{yyvs}->[$p->{yyvsp}-1]."'}->Clone;"); }
+}
+if ($p->{yyn} == 3) {
+{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-0]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-0]."->Complement(".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
+}
+if ($p->{yyn} == 4) {
+{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-0]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-0]."->Complement(".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
+}
+if ($p->{yyn} == 5) {
+{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->ExclusiveOr(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
+}
+if ($p->{yyn} == 6) {
+{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->ExclusiveOr(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
+}
+if ($p->{yyn} == 7) {
+{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Difference(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
+}
+if ($p->{yyn} == 8) {
+{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Difference(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
+}
+if ($p->{yyn} == 9) {
+{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Intersection(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
+}
+if ($p->{yyn} == 10) {
+{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Intersection(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
+}
+if ($p->{yyn} == 11) {
+{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Union(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
+}
+if ($p->{yyn} == 12) {
+{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Union(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
+}
+if ($p->{yyn} == 13) {
+{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-1]; }
+}
+    $p->{yyssp} -= $p->{yym};
+    $p->{yystate} = $p->{yyss}->[$p->{yyssp}];
+    $p->{yyvsp} -= $p->{yym};
+    $p->{yym} = $yylhs[$p->{yyn}];
+    if ($p->{yystate} == 0 && $p->{yym} == 0)
+    {
+      warn("yydebug: after reduction, shifting from state 0 ",
+            "to state $YYFINAL\n") if $p->{yydebug};
+      $p->{yystate} = $YYFINAL;
+      $p->{yyss}->[++$p->{yyssp}] = $YYFINAL;
+      $p->{yyvs}->[++$p->{yyvsp}] = $p->{yyval};
+      if ($p->{yychar} < 0)
+      {
+        if ((($p->{yychar}, $p->{yylval}) = 
+            &{$p->{yylex}}($s)) < 0) { $p->{yychar} = 0; }
+        if ($p->{yydebug})
+        {
+          $p->{yys} = '';
+          if ($p->{yychar} <= $#yyname) 
+            { $p->{yys} = $yyname[$p->{yychar}]; }
+          if (!$p->{yys}) { $p->{yys} = 'illegal-symbol'; }
+          warn("yydebug: state $YYFINAL, reading " . 
+               $p->{yychar} . " (" . $p->{yys} . ")\n");
+        }
+      }
+      return ($p->{yyvs}->[1]) if $p->{yychar} == 0;
+      next yyloop;
+    }
+    if (($p->{yyn} = $yygindex[$p->{yym}]) && 
+        ($p->{yyn} += $p->{yystate}) >= 0 && 
+        $p->{yyn} <= $#yycheck && 
+        $yycheck[$p->{yyn}] == $p->{yystate})
+    {
+        $p->{yystate} = $yytable[$p->{yyn}];
+    } else {
+        $p->{yystate} = $yydgoto[$p->{yym}];
+    }
+    warn("yydebug: after reduction, shifting from state " . 
+        $p->{yyss}->[$p->{yyssp}] . " to state " . 
+        $p->{yystate} . "\n") if $p->{yydebug};
+    $p->{yyss}[++$p->{yyssp}] = $p->{yystate};
+    $p->{yyvs}[++$p->{yyvsp}] = $p->{yyval};
+  } # yyloop
+} # yyparse
+
+#   create new set variable
+$tmpcnt = 0;
+sub newvar {
+    my ($name) = @_;
+    my ($tmp);
+
+    if ($main::CFG->{SLICE}->{SET}->{OBJ}->{"$name"} eq '') {
+        main::printwarning("no such slice '$name'\n") if $undef;
+        #    The $undef string is caught by caller, it is used
+        #    to trap warnings depending on the -y command line flag.
+        die $undef."\n" if $undef > 1;
+        $main::CFG->{SLICE}->{SET}->{OBJ}->{"$name"} =
+                $main::CFG->{SLICE}->{SET}->{OBJ}->{DEF0}->Clone;
+    }
+    $tmp = sprintf("\$T%03d", $tmpcnt++);
+    return $tmp;
+}
+
+#   the lexical scanner
+sub yylex {
+    local (*s) = @_;
+    my ($c, $val);
+
+    #   ignore whitespaces
+    $s =~ s|^\s+||;
+
+    #   recognize end of string
+    return 0 if ($s eq '');
+
+    #   found a token
+    if ($s =~ s|^([_A-Z0-9*{}]+)||) {
+        $val = $1;
+
+        #   if its a wildcarded slice name we have
+        #   to construct the slice union on-the-fly
+        if ($val =~ m|\*|) {
+            my $pat = $val;
+            $pat =~ s|\*|\.\*|g;
+
+            #   treat special *{...} sequence
+            $excl = '';
+            while ($pat =~ s|^(.*?)\.\*\{([_A-Z0-9]+)\}(.*)$|$1\.\*$3|) {
+                my $temp = $1 . $2 . $3;
+                $temp =~ s|\.\*\{[_A-Z0-9]+\}|\.\*|g;
+                $excl .= "return 1 if m/^$temp\$/;";
+            }
+            $sub_excl = eval "sub { \$_ = shift; $excl; return 0}";
+
+            my $slice;
+            my @slices = ();
+            foreach $slice (keys(%{$main::CFG->{SLICE}->{SET}->{ASC}})) {
+                if ($slice =~ m|^$pat$|) {
+                    push(@slices, $slice) unless &$sub_excl($slice);
+                }
+            }
+            if ($#slices == 0) {
+                $val = $slices[0];
+            }
+            elsif ($#slices > 0) {
+                $s = join('u', @slices).')'.$s;
+                return ord('(');
+            }
+            else {
+                main::printwarning("no existing slice matches `$val'\n") if $wildcard;
+                #    The $wildcard string is caught by caller, it is used
+                #    to trap warnings depending on the -y command line flag.
+                die $wildcard."\n" if $wildcard > 1;
+            }
+        }
+        return ($SLICE, $val);
+    }
+
+    #   else give back one plain character
+    $c = substr($s, 0, 1);
+    $s = substr($s, 1);
+    return ord($c);
+}
+
+#   and error function
+sub yyerror {
+    my ($msg, $s) = @_;
+    die "$msg at $s.\n";
+}
+
+#
+#  The top-level function which gets called by the user
+#
+#  ($cmds, $var) = SliceTerm::Parse($term, $status);
+#
+
+package SliceTerm;
+
+sub Parse {
+    local($str, $status) = @_;
+    my($p, $var, $cmds);
+
+    @SliceTermParser::OUT = ();
+    $SliceTermParser::undef = $status->{u};
+    $SliceTermParser::wildcard = $status->{w};
+    $p = SliceTermParser->new(\&SliceTermParser::yylex, \&SliceTermParser::yyerror, 0);
+    eval {$var = $p->yyparse(*str);};
+    if ($@ =~ s/^(\d)$//) {
+        main::error("Execution stopped\n") if $1 > 2;
+        return ();
+    }
+    $cmds = join("\n", @SliceTermParser::OUT) . "\n";
+
+    return ($cmds, $var);
+}
+
+package main;
+
+1;
+##EOF##
+1;

File src/wml_backend/p9_slice/slice_main.pl

 eval 'exec @PATH_PERL@ -S $0 ${1+"$@"}'
     if $running_under_some_shell;
 
-require 5.003;
+use strict;
+use warnings;
+
+use vars qw($CFG);
 
 BEGIN { $^W = 0; } # get rid of nasty warnings
 
-#   bootstrapping private installed modules
-use lib "@INSTALLPRIVLIB@";
-use lib "@INSTALLARCHLIB@";
-
 ##         _ _          
 ##     ___| (_) ___ ___ 
 ##    / __| | |/ __/ _ \
 use IO::File 1.07;
 use Bit::Vector 5.0;
 
-require "slice_vers.pl";
-require "slice_util.pl";
-require "slice_term.pl";
-require "slice_setup.pl";
-require "slice_pass1.pl";
-require "slice_pass2.pl";
-require "slice_pass3.pl";
+
+##
+##  slice_vers.pl -- Version Information for Slice (syntax: Perl)
+##  [automatically generated and maintained by GNU shtool]
+##
+
+my $slice_version = {
+    'v_hex'   => 0x103208,
+    'v_short' => "1.3.8",
+    'v_long'  => "1.3.8 (10-Feb-2002)",
+    'v_tex'   => "This is Slice, Version 1.3.8 (10-Feb-2002)",
+    'v_gnu'   => "Slice 1.3.8 (10-Feb-2002)",
+    'v_web'   => "Slice/1.3.8",
+    'v_sccs'  => "@(#)Slice 1.3.8 (10-Feb-2002)",
+    'v_rcs'   => "\$Id: Slice 1.3.8 (10-Feb-2002) $/"
+};
+
+##
+##  slice_util.pl -- Utility functions
+##  Copyright (c) 1997-2002 Ralf S. Engelschall. 
+##  Copyright (c) 1999-2002 Denis Barbier.
+##
+
+package main;
+
+sub verbose {
+    my ($str) = @_;
+
+    if ($main::CFG->{OPT}->{X}) {
+        $str =~ s|^|** Slice:Verbose: |mg;
+        print STDERR $str;
+    }
+}
+
+sub printerror {
+    my ($str) = @_;
+
+    $str =~ s|^|** Slice:Error: |mg;
+    print STDERR $str;
+}
+
+sub error {
+    my ($str) = @_;
+
+    printerror($str);
+    exit(1);
+}
+
+sub fileerror {
+    my $file  = shift;
+    my ($str) = @_;
+
+    printerror($str);
+    unlink $file;
+    exit(1);
+}
+
+sub printwarning {
+    my ($str) = @_;
+
+    $str =~ s|^|** Slice:Warning: |mg;
+    print STDERR $str;
+}
+
+require SliceTerm;
+
+sub usage {
+    print STDERR "Usage: slice [options] [file]\n";
+    print STDERR "\n";
+    print STDERR "Options:\n";
+    print STDERR "  -o, --outputfile=FILESPEC  create output file(s)\n";
+    print STDERR "  -y, --output-policy=STRING set default output policy\n";
+    print STDERR "  -v, --verbose              enable verbose mode\n";
+    print STDERR "  -V, --version              display version string\n";
+    print STDERR "  -h, --help                 display usage page\n";
+    print STDERR "\n";
+    print STDERR "FILESPEC format:\n";
+    print STDERR "\n";
+    print STDERR "  [SLICETERM:]PATH[\@CHMODOPT]\n";
+    print STDERR "\n";
+    print STDERR "  SLICETERM ..... a set-theory term describing the slices\n";
+    print STDERR "  PATH .......... a filesystem path to the outputfile\n";
+    print STDERR "  CHMODOPT ...... permission change options for 'chmod'\n";
+    print STDERR "\n";
+    exit(1);
+}
+
+sub hello {
+    print STDERR "$slice_version->{v_tex}\n";
+    print STDERR <<'EOT';
+Copyright (c) 1997-2002 Ralf S. Engelschall. 
+Copyright (c) 1999-2002 Denis Barbier.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+EOT
+    exit(0);
+}
+
+sub setup {
+    my ($CFG) = @_;
+
+    #   parse command line options
+    my $opt_h = 0;
+    my $opt_V = 0;
+    my $opt_v = 0;
+    my $opt_y = '';
+    my @opt_o = ();
+    my $INPUT;
+    my (@options_list) = (
+        "v|verbose",
+        "V|version",
+        "h|help",
+        "o|outputfile=s@",
+        "y|output-policy=s",
+    );
+    $SIG{'__WARN__'} = sub { 
+        print STDERR "Slice:Error: $_[0]";
+    };
+
+    $Getopt::Long::bundling = 1;
+    $Getopt::Long::getopt_compat = 0;
+    if (not Getopt::Long::GetOptions(@options_list)) {
+        print STDERR "Try `$0 --help' for more information.\n";
+        exit(0);
+    }
+    $SIG{'__WARN__'} = undef;
+    usage($0) if ($opt_h);
+    hello() if ($opt_V);
+
+    #   process command line arguments and
+    #   read input file
+    if (($#ARGV == 0 and $ARGV[0] eq '-') or $#ARGV == -1) {
+        my $fp = new IO::Handle;
+        $fp->fdopen(fileno(STDIN), "r")
+            || error("Unable to load STDIN: $!\n");
+        local ($/) = undef;
+        $INPUT = <$fp>;
+        $fp->close()
+            || error("Unable to close STDIN: $!\n");
+    }
+    elsif ($#ARGV == 0) {
+        my $fp = new IO::File;
+        $fp->open($ARGV[0])
+            || error("Unable to load $ARGV[0]: $!\n");
+        local ($/) = undef;
+        $INPUT = <$fp>;
+        $fp->close()
+            || error("Unable to close $ARGV[0]: $!\n");
+    }
+    else {
+        usage();
+    }
+
+    #   add additional options
+    $INPUT =~ s|^%!slice\s+(.*?)\n|push(@ARGV, split(' ', $1)), ''|egim;
+    if (not Getopt::Long::GetOptions(@options_list)) {
+        usage();
+    }
+    if ($#opt_o == -1) {
+        @opt_o = ( "ALL:-" ); # default is all on stdout
+    }
+
+    #   setup the $CFG hash
+    $CFG->{INPUT} = {};
+    $CFG->{INPUT}->{SRC}   = $INPUT;  # original source
+    $CFG->{INPUT}->{PLAIN} = '';      # source without slice delimiters
+    $CFG->{OPT} = {};    
+    $CFG->{OPT}->{X} = $opt_v;        # option -v
+    $CFG->{OPT}->{O} = [ @opt_o ];    # options -o
+    $CFG->{OPT}->{Y} = {
+        'u' => 0, 'w' => 0,
+        'z' => 0, 's' => 0,
+    };
+    my $modifier = $opt_y;
+    foreach (qw(u w z s)) {
+        ($modifier =~ m/$_(\d+)/) and $CFG->{OPT}->{Y}->{$_} = $1;
+    }
+    $CFG->{SLICE} = {};
+    $CFG->{SLICE}->{SET} = {};       
+    $CFG->{SLICE}->{SET}->{ASC} = {}; # slice set, represented in ASCII
+    $CFG->{SLICE}->{SET}->{OBJ} = {}; # slice set, represented as Bit::Vector object
+    $CFG->{SLICE}->{MINLEVELS}  = {}; # slice min levels
+    $CFG->{SLICE}->{MAXLEVEL}   = 0;  # maximum slice level
+}
+
+##
+##
+##  Pass 1: Determine delimiters
+##
+##
+
+sub pass1 {
+    my ($CFG) = @_;
+
+    my (@CURRENT_SLICE_NAMES, %CURRENT_LEVEL_BRAIN, $CURRENT_LEVEL_SET);
+    my ($INPUT, $prolog, $pos, $inputpos, $prev, $name, $namex, $L, $open);
+
+    verbose("\nPass 1: Determine delimiters\n\n");
+
+    @CURRENT_SLICE_NAMES = ();
+    %CURRENT_LEVEL_BRAIN = ();
+    $CURRENT_LEVEL_SET   = new Bit::Vector(512);
+
+    #   allocate the next free level starting from 1
+    my $alloclevel = sub {
+        my ($i);
+
+        for ($i = 0; $i <= $CURRENT_LEVEL_SET->Max(); $i++) {
+            last if (not $CURRENT_LEVEL_SET->bit_test($i));
+        }
+        $CURRENT_LEVEL_SET->Bit_On($i);
+        return $i + 1;
+    };
+
+    #   clear the given level
+    my $clearlevel = sub {
+        my ($i) = @_;
+
+        $CURRENT_LEVEL_SET->Bit_Off($i - 1);
+    };
+
+    $INPUT = $CFG->{INPUT}->{SRC};
+    $open  = 0;
+    $pos   = 0;
+    $prev  = 0;
+    while ($INPUT =~ m/
+             (?=[\[:])                 #  Consider only sequences beginning
+                                       #  with `[' or `:'
+             (?:\[([A-Z][_A-Z0-9]*):   #  Begin delimiter
+                      |
+             :([A-Z][_A-Z0-9]*)?\])    #  End delimiter
+                      /gx) {
+        if (defined ($1)) {
+            #
+            #   begin delimiter found
+            #
+            $name     = $1;
+            $inputpos = pos($INPUT);
+            $prolog   = substr ($INPUT, $prev, $inputpos - $prev - length ($name) - 2);
+
+            #   add prolog
+            $CFG->{INPUT}->{PLAIN} .= $prolog;
+
+            #   and store position of next character in input datas
+            $pos  += length($prolog);
+            $prev  = $inputpos;
+
+            $L = $alloclevel->();                 # allocate next free level
+
+            push(@CURRENT_SLICE_NAMES, $name);  # remember name  for end delimiter
+            $CURRENT_LEVEL_BRAIN{"$name"} .= ":$L";# remember level for end delimiter
+            if ($CFG->{SLICE}->{MINLEVELS}->{"$name"} eq '' or
+                $CFG->{SLICE}->{MINLEVELS}->{"$name"} > $L) {
+                $CFG->{SLICE}->{MINLEVELS}->{"$name"} = $L;
+            }
+
+            #  now begin entry with LEVEL:START
+            $CFG->{SLICE}->{SET}->{ASC}->{"$name:$L"} .=
+                 ($CFG->{SLICE}->{SET}->{ASC}->{"$name:$L"} ? ',' : '') . "$L:$pos";
+
+            #  adjust notice about highest level
+            $CFG->{SLICE}->{MAXLEVEL} = ($CFG->{SLICE}->{MAXLEVEL} < $L ?
+                                         $L : $CFG->{SLICE}->{MAXLEVEL});
+
+            verbose("    slice `$name': begin at $pos, level $L\n");
+
+            $open++;
+        }
+        elsif ($open > 0) {
+            #
+            #   end delimiter found
+            #
+            $name     = $2;
+            $inputpos = pos($INPUT);
+            $prolog   = substr ($INPUT, $prev, $inputpos - $prev - length ($name) - 2);
+
+            #   add prolog
+            $CFG->{INPUT}->{PLAIN} .= $prolog;
+
+            #   and store position of next character in input datas
+            $pos  += length($prolog) - 1;
+            $prev  = $inputpos;
+
+            $namex = pop(@CURRENT_SLICE_NAMES);      # take remembered name
+            $name  = $namex if ($name eq '');        # fill name because of shortcut syntax
+            $CURRENT_LEVEL_BRAIN{"$name"} =~ s|:(\d+)$||; # take remembered level
+            $L = $1;
+
+            $clearlevel->($L);                         # de-allocate level
+
+            # now end entry with :END
+            $CFG->{SLICE}->{SET}->{ASC}->{"$name:$L"} .= ":$pos";
+
+            verbose("    slice `$name': end at $pos, level $L\n");
+
+            $pos++;
+            $open--;
+        }
+    }
+    # add all remaining input
+    $CFG->{INPUT}->{PLAIN} .= substr ($INPUT, $prev);
+
+    #   check: were all opened slices really closed?
+    if ($CURRENT_LEVEL_SET->Norm > 0) {
+        my $i;
+        my $err = '';
+        for ($i = 0; $i <= $CURRENT_LEVEL_SET->Max(); $i++) {
+            if ($CURRENT_LEVEL_SET->bit_test($i)) {
+                my $name;
+                foreach $name (keys(%CURRENT_LEVEL_BRAIN)) {
+                    if ($CURRENT_LEVEL_BRAIN{$name} == ($i+1)) {
+                        $err .= " `$name'";
+                    }
+                }
+            }
+        }
+        error("Some slices were not closed:$err\n");
+    }
+}
+
+##
+##
+##  Pass 2: Calculation of slice sets
+##
+##
+
+sub pass2 {
+    my ($CFG) = @_;
+
+    my ($n, $asc, $slice, $set, $setA);
+
+    verbose("\nPass 2: Calculation of slice sets\n\n");
+
+    #  convert ASCII set representation string into internal set object
+    sub asc2set {
+        my ($asc, $set, $onlylevel, $notcleared) = @_;
+        my ($i, $I, $internal, $from, $to, $level);
+
+        $set->Empty() if (($notcleared eq '') or (not $notcleared));
+        return $set if ($asc =~ m|^\d+:0:-1$|); # string represents the empty set
+
+        #   split out the interval substrings 
+        my @I = ($asc);
+        @I = split(',', $asc) if (index($asc, ',') > 0);
+
+        #   iterate over each interval and
+        #   set the corresponding elements in the set
+        foreach my $interval (@I) {
+            ($level, $from, $to) = ($interval =~ m|^(\d+):(\d+):(\d+)$|);
+            next if (($onlylevel ne '') and ($level != $onlylevel)); 
+            next if ($from > $to);
+            $set->Interval_Fill($from, $to);
+        }
+    }
+
+    $n = length($CFG->{INPUT}->{PLAIN})+1;
+    $set  = new Bit::Vector($n); # working set
+    $setA = new Bit::Vector($n); # "all" set
+
+    #   restore slice names
+    foreach $slice (keys(%{$CFG->{SLICE}->{SET}->{ASC}})) {
+        $asc = $CFG->{SLICE}->{SET}->{ASC}->{$slice};
+        delete $CFG->{SLICE}->{SET}->{ASC}->{$slice};
+        $slice =~ s|:\d+$||g;
+        $CFG->{SLICE}->{SET}->{ASC}->{$slice} .=
+                 ($CFG->{SLICE}->{SET}->{ASC}->{"$slice"} ? ',' : '') . $asc;
+    }
+
+    #   convert ASCII representation to real internal set objects
+    foreach $slice (keys(%{$CFG->{SLICE}->{SET}->{ASC}})) {
+        $asc = $CFG->{SLICE}->{SET}->{ASC}->{$slice};
+        $set->Empty();
+        asc2set($asc, $set);
+        $CFG->{SLICE}->{SET}->{OBJ}->{$slice} = $set->Clone();
+    }
+
+    #   define the various (un)defined slice areas
+    $set->Fill();
+    $CFG->{SLICE}->{SET}->{OBJ}->{'UNDEF0'} = $set->Clone();
+    $set->Empty();
+    $CFG->{SLICE}->{SET}->{OBJ}->{'DEF0'} = $set->Clone();
+    $setA->Empty();
+    for (my $i = 1; $i <= $CFG->{SLICE}->{MAXLEVEL}; $i++) {
+        $set->Empty();
+        foreach $slice (keys(%{$CFG->{SLICE}->{SET}->{ASC}})) {
+            $asc = $CFG->{SLICE}->{SET}->{ASC}->{$slice};
+            asc2set($asc, $set, $i, 1); # load $set with entries of level $i
+            $setA->Union($setA, $set);   # add to $setA these entries
+        }
+        $CFG->{SLICE}->{SET}->{OBJ}->{"DEF$i"} = $set->Clone();
+        $set->Complement($set);
+        $CFG->{SLICE}->{SET}->{OBJ}->{"UNDEF$i"} = $set->Clone();
+    }
+    $CFG->{SLICE}->{SET}->{OBJ}->{'DEF'} = $setA->Clone();
+    $setA->Complement($setA);
+    $CFG->{SLICE}->{SET}->{OBJ}->{'UNDEF'} = $setA->Clone();
+    $CFG->{SLICE}->{SET}->{OBJ}->{'ALL'} = $CFG->{SLICE}->{SET}->{OBJ}->{'UNDEF0'};
+
+    #   define the various slice areas which are not overwritten
+    foreach $slice (keys(%{$CFG->{SLICE}->{SET}->{ASC}})) {
+        $asc = $CFG->{SLICE}->{SET}->{ASC}->{$slice};
+        $set->Empty();
+        asc2set($asc, $set);
+        my $L = $CFG->{SLICE}->{MINLEVELS}->{$slice};
+        for (my $i = $L+1; $i <= $CFG->{SLICE}->{MAXLEVEL}; $i++) {
+            $set->Difference($set, $CFG->{SLICE}->{SET}->{OBJ}->{"DEF$i"});
+        }
+        $CFG->{SLICE}->{SET}->{OBJ}->{"NOV_$slice"} = $set->Clone();
+    }
+
+    if ($CFG->{OPT}->{X}) {
+        foreach $slice (sort(keys(%{$CFG->{SLICE}->{SET}->{OBJ}}))) {
+            $set = $CFG->{SLICE}->{SET}->{OBJ}->{$slice};
+            if ($set->Norm > 0) {
+                verbose("    slice `$slice': " . $set->to_ASCII() . "\n");
+            }
+            else {
+                verbose("    slice `$slice': -Empty-\n");
+            }
+        }
+    }
+}
+
+
+##
+##
+##  Pass 3: Output generation
+##
+##
+
+sub pass3 {
+    my ($CFG) = @_;
+
+    my ($slice, $outfile, $chmod, $status, $modifier, $out);
+    my ($set, $cmds, $var);
+    my ($start, $min, $max);
+    my ($entry);
+
+    verbose("\nPass 3: Output generation\n\n");
+
+    foreach $entry (@{$CFG->{OPT}->{O}}) {
+
+        #   determine skip options:
+        #     u: a set is undefined
+        #     w: a wildcard set does not match
+        #     z: result is empty
+        #     s: result is only composed of whitespaces
+        $status = $CFG->{OPT}->{Y};
+        if ($entry =~ s|\#([suwz\d]+)$||) {
+            $modifier = $1;
+            foreach (qw(u w z s)) {
+                ($modifier =~ m/$_(\d+)/) and $status->{$_} = $1;
+            }
+        }
+        if ($entry =~ m|^([_A-Z0-9~!+u%n\-\\^x*{}()@]+):(.+)@(.+)$|) {
+            # full syntax
+            ($slice, $outfile, $chmod) = ($1, $2, $3);
+        }
+        elsif ($entry =~ m|^([_A-Z0-9~!+u%n\-\\^x*{}()@]+):(.+)$|) {
+            # only slice and file
+            ($slice, $outfile, $chmod) = ($1, $2, '');
+        }
+        elsif ($entry =~ m|^([^@]+)@(.+)$|) {
+            # only file and chmod
+            ($slice, $outfile, $chmod) = ('ALL', $1, $2);
+        }
+        else {
+            # only file 
+            ($slice, $outfile, $chmod) = ('ALL', $entry, '');
+        }
+        verbose("    file `$outfile': sliceterm='$slice', chmodopts='$chmod'\n");
+        #   parse the sliceterm and create corresponding
+        #   Perl 5 statement containing Bit::Vector calls
+        ($cmds, $var) = SliceTerm::Parse($slice, $status);
+    
+        #   skip file if requested by options
+        if ($status->{u} > 0 and !defined($cmds)) {
+                printwarning("Undefined set: skip generation of $outfile\n");
+                next if $status->{u} > 1;
+        }
+
+        #   just debugging...
+        if ($CFG->{OPT}->{X}) {
+            verbose("        calculated Perl 5 set term:\n");
+            verbose("        ----\n");
+            my $x = $cmds; 
+            $x =~ s|\n+$||;
+            $x =~ s|\n|\n        |g;
+            verbose("        $x\n");
+            verbose("        ----\n");
+        }
+
+        #   now evaluate the Bit::Vector statements
+        #   and move result to $set
+        eval "$cmds; \$set = $var";
+ 
+        #   now scan the set and write out characters
+        #   which have a corresponding bit set.
+        $start = 0;
+        $out = '';
+        while (($start < $set->Size()) &&
+               (($min, $max) = $set->Interval_Scan_inc($start))) {
+            $out .= substr($CFG->{INPUT}->{PLAIN},
+                               $min, ($max-$min+1));
+            $start = $max + 2;
+        }
+
+        #   skip file if requested by options
+        if ($status->{z} > 0 and $out eq '') {
+                printwarning("Empty output: skip generation of $outfile\n");
+                main::error("Execution stopped\n") if $status->{z} > 2;
+                next if $status->{z} == 2;
+        }
+        if ($status->{s} > 0 and ($out eq '' or $out !~ m/\S/)) {
+                printwarning("Whitespace only: skip generation of $outfile\n");
+                main::error("Execution stopped\n") if $status->{s} > 2;
+                next if $status->{s} == 2;
+        }
+
+        #   open output file
+        if ($outfile eq '-') {
+            print $out;
+        }
+        else {
+            open(OUT, ">$outfile")
+                or main::error("Unable to write into $outfile: $!\n");
+            print OUT $out
+                or main::fileerror($outfile, "Unable to write into $outfile: $!\n");
+            close(OUT)
+                or main::fileerror($outfile, "Unable to close $outfile: $!\n");
+        }
+
+        #   additionally run chmod on the output file
+        if ($outfile ne '-' and $chmod ne '' and -f $outfile) {
+            system("chmod $chmod $outfile");
+        }
+    }
+}
 
 $CFG = {};
 setup($CFG);

File src/wml_backend/p9_slice/slice_term.pl

-# @(#)yaccpar 1.8 (Berkeley) 01/20/91 (JAKE-P5BP-0.6 04/26/98)
-package SliceTermParser;
-;##
-;##  slice_term.y -- YACC parser for slice terms
-;##  Copyright (c) 1997-2002 Ralf S. Engelschall. 
-;##  Copyright (c) 1999-2002 Denis Barbier.
-;##
-
-package SliceTermParser;
-$SLICE=257;
-$YYERRCODE=256;
-@yylhs = (                                               -1,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,
-);
-@yylen = (                                                2,
-    1,    2,    2,    2,    3,    3,    3,    3,    3,    3,
-    3,    3,    3,
-);
-@yydefred = (                                             0,
-    0,    0,    0,    0,    0,    2,    3,    4,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,   13,    0,    0,
-    0,    0,    0,    0,    9,   10,
-);
-@yydgoto = (                                              5,
-);
-@yysindex = (                                           -33,
-  -60,  -33,  -33,  -33,   -7,    0,    0,    0,  -12,  -33,
-  -33,  -33,  -33,  -33,  -33,  -33,  -33,    0,  -31,  -31,
-   24,   24,  -36,  -36,    0,    0,
-);
-@yyrindex = (                                             0,
-    2,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,   15,   17,
-    9,   14,    3,    8,    0,    0,
-);
-@yygindex = (                                           135,
-);
-$YYTABLESIZE=224;
-@yytable = (                                              2,
-   17,    1,    5,    6,    0,   17,    4,    6,   11,    0,
-    0,   13,    0,   12,    7,    0,    8,    0,    0,    0,
-    0,    0,    0,    0,   17,    0,    0,    0,   18,   17,
-   13,    0,   11,    0,    0,   13,    0,   11,    1,    0,
-    0,    0,    1,    5,    1,    5,    1,    5,    6,   11,
-    6,   11,    6,   11,   12,    7,   12,    8,   12,    7,
-   17,    8,   15,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,   16,    0,    0,    0,    0,   16,   10,
-    0,   15,    0,    0,   10,   12,   15,    0,   14,    0,
-    0,    0,    3,    1,    5,    1,    5,   16,    0,    6,
-   11,    6,   16,    0,   12,   12,    7,   14,    8,   12,
-    0,    1,   14,    0,    0,    0,    0,   15,    1,    5,
-    0,    1,    5,    0,    6,   11,    0,    6,    0,    0,
-   12,    0,    0,   16,    0,    0,    7,    8,    9,    0,
-    0,    0,    0,   14,   19,   20,   21,   22,   23,   24,
-   25,   26,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    1,
-);
-@yycheck = (                                             33,
-   37,    0,    0,   64,   -1,   37,   40,    0,    0,   -1,
-   -1,   43,   -1,    0,    0,   -1,    0,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   37,   -1,   -1,   -1,   41,   37,
-   43,   -1,   45,   -1,   -1,   43,   -1,   45,   37,   -1,
-   -1,   -1,   41,   41,   43,   43,   45,   45,   41,   41,
-   43,   43,   45,   45,   41,   41,   43,   41,   45,   45,
-   37,   45,   94,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  110,   -1,   -1,   -1,   -1,  110,   92,
-   -1,   94,   -1,   -1,   92,  117,   94,   -1,  120,   -1,
-   -1,   -1,  126,   92,   92,   94,   94,  110,   -1,   92,
-   92,   94,  110,   -1,  117,   92,   92,  120,   92,  117,
-   -1,  110,  120,   -1,   -1,   -1,   -1,   94,  117,  117,
-   -1,  120,  120,   -1,  117,  117,   -1,  120,   -1,   -1,
-  117,   -1,   -1,  110,   -1,   -1,    2,    3,    4,   -1,
-   -1,   -1,   -1,  120,   10,   11,   12,   13,   14,   15,
-   16,   17,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  257,
-);
-$YYFINAL=5;
-#ifndef YYDEBUG
-#define YYDEBUG 0
-#endif
-$YYMAXTOKEN=257;
-#if YYDEBUG
-@yyname = (
-"end-of-file",'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
-"'!'",'','','',"'%'",'','',"'('","')'",'',"'+'",'',"'-'",'','','','','','','','','','','','','','','',
-'','','',"'\@'",'','','','','','','','','','','','','','','','','','','','','','','','','','','',"'\\\\'",'',
-"'^'",'','','','','','','','','','','','','','','',"'n'",'','','','','','',"'u'",'','',"'x'",'','','','','',
-"'~'",'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
-'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
-'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
-'','','','','','','','','','','','','',"SLICE",
-);
-@yyrule = (
-"\$accept : expr",
-"expr : SLICE",
-"expr : SLICE '\@'",
-"expr : '!' expr",
-"expr : '~' expr",
-"expr : expr 'x' expr",
-"expr : expr '^' expr",
-"expr : expr '\\\\' expr",
-"expr : expr '-' expr",
-"expr : expr 'n' expr",
-"expr : expr '%' expr",
-"expr : expr 'u' expr",
-"expr : expr '+' expr",
-"expr : '(' expr ')'",
-);
-#endif
-sub yyclearin {
-  my  $p;
-  ($p) = @_;
-  $p->{yychar} = -1;
-}
-sub yyerrok {
-  my  $p;
-  ($p) = @_;
-  $p->{yyerrflag} = 0;
-}
-sub new {
-  my $p = bless {}, $_[0];
-  $p->{yylex} = $_[1];
-  $p->{yyerror} = $_[2];
-  $p->{yydebug} = $_[3];
-  return $p;
-}
-sub YYERROR {
-  my  $p;
-  ($p) = @_;
-  ++$p->{yynerrs};
-  $p->yy_err_recover;
-}
-sub yy_err_recover {
-  my  $p;
-  ($p) = @_;
-  if ($p->{yyerrflag} < 3)
-  {
-    $p->{yyerrflag} = 3;
-    while (1)
-    {
-      if (($p->{yyn} = $yysindex[$p->{yyss}->[$p->{yyssp}]]) && 
-          ($p->{yyn} += $YYERRCODE) >= 0 && 
-          $p->{yyn} <= $#yycheck &&
-          $yycheck[$p->{yyn}] == $YYERRCODE)
-      {
-        warn("yydebug: state " . 
-                     $p->{yyss}->[$p->{yyssp}] . 
-                     ", error recovery shifting to state" . 
-                     $yytable[$p->{yyn}] . "\n") 
-                       if $p->{yydebug};
-        $p->{yyss}->[++$p->{yyssp}] = 
-          $p->{yystate} = $yytable[$p->{yyn}];
-        $p->{yyvs}->[++$p->{yyvsp}] = $p->{yylval};
-        next yyloop;
-      }
-      else
-      {
-        warn("yydebug: error recovery discarding state ".
-              $p->{yyss}->[$p->{yyssp}]. "\n") 
-                if $p->{yydebug};
-        return(undef) if $p->{yyssp} <= 0;
-        --$p->{yyssp};
-        --$p->{yyvsp};
-      }
-    }
-  }
-  else
-  {
-    return (undef) if $p->{yychar} == 0;
-    if ($p->{yydebug})
-    {
-      $p->{yys} = '';
-      if ($p->{yychar} <= $YYMAXTOKEN) { $p->{yys} = 
-        $yyname[$p->{yychar}]; }
-      if (!$p->{yys}) { $p->{yys} = 'illegal-symbol'; }
-      warn("yydebug: state " . $p->{yystate} . 
-                   ", error recovery discards " . 
-                   "token " . $p->{yychar} . "(" . 
-                   $p->{yys} . ")\n");
-    }
-    $p->{yychar} = -1;
-    next yyloop;
-  }
-0;
-} # yy_err_recover
-
-sub yyparse {
-  my  $p;
-  my $s;
-  ($p, $s) = @_;
-  if ($p->{yys} = $ENV{'YYDEBUG'})
-  {
-    $p->{yydebug} = int($1) if $p->{yys} =~ /^(\d)/;
-  }
-
-  $p->{yynerrs} = 0;
-  $p->{yyerrflag} = 0;
-  $p->{yychar} = (-1);
-
-  $p->{yyssp} = 0;
-  $p->{yyvsp} = 0;
-  $p->{yyss}->[$p->{yyssp}] = $p->{yystate} = 0;
-
-yyloop: while(1)
-  {
-    yyreduce: {
-      last yyreduce if ($p->{yyn} = $yydefred[$p->{yystate}]);
-      if ($p->{yychar} < 0)
-      {
-        if ((($p->{yychar}, $p->{yylval}) = 
-            &{$p->{yylex}}($s)) < 0) { $p->{yychar} = 0; }
-        if ($p->{yydebug})
-        {
-          $p->{yys} = '';
-          if ($p->{yychar} <= $#yyname) 
-             { $p->{yys} = $yyname[$p->{yychar}]; }
-          if (!$p->{yys}) { $p->{yys} = 'illegal-symbol'; };
-          warn("yydebug: state " . $p->{yystate} . 
-                       ", reading " . $p->{yychar} . " (" . 
-                       $p->{yys} . ")\n");
-        }
-      }
-      if (($p->{yyn} = $yysindex[$p->{yystate}]) && 
-          ($p->{yyn} += $p->{yychar}) >= 0 && 
-          $p->{yyn} <= $#yycheck &&
-          $yycheck[$p->{yyn}] == $p->{yychar})
-      {
-        warn("yydebug: state " . $p->{yystate} . 
-                     ", shifting to state " .
-              $yytable[$p->{yyn}] . "\n") if $p->{yydebug};
-        $p->{yyss}->[++$p->{yyssp}] = $p->{yystate} = 
-          $yytable[$p->{yyn}];
-        $p->{yyvs}->[++$p->{yyvsp}] = $p->{yylval};
-        $p->{yychar} = (-1);
-        --$p->{yyerrflag} if $p->{yyerrflag} > 0;
-        next yyloop;
-      }
-      if (($p->{yyn} = $yyrindex[$p->{yystate}]) && 
-          ($p->{yyn} += $p->{'yychar'}) >= 0 &&
-          $p->{yyn} <= $#yycheck &&
-          $yycheck[$p->{yyn}] == $p->{yychar})
-      {
-        $p->{yyn} = $yytable[$p->{yyn}];
-        last yyreduce;
-      }
-      if (! $p->{yyerrflag}) {
-        &{$p->{yyerror}}('syntax error', $s);
-        ++$p->{yynerrs};
-      }
-      return(undef) if $p->yy_err_recover;
-    } # yyreduce
-    warn("yydebug: state " . $p->{yystate} . 
-                 ", reducing by rule " . 
-                 $p->{yyn} . " (" . $yyrule[$p->{yyn}] . 
-                 ")\n") if $p->{yydebug};
-    $p->{yym} = $yylen[$p->{yyn}];
-    $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}+1-$p->{yym}];
-if ($p->{yyn} == 1) {
-{ $p->{yyval} = newvar($p->{yyvs}->[$p->{yyvsp}-0]); push(@OUT, "my ".$p->{yyval}." = \$CFG->{SLICE}->{SET}->{OBJ}->{'".$p->{yyvs}->[$p->{yyvsp}-0]."'}->Clone;"); }
-}
-if ($p->{yyn} == 2) {
-{ $p->{yyval} = newvar($p->{yyvs}->[$p->{yyvsp}-1]); push(@OUT, "my ".$p->{yyval}." = \$CFG->{SLICE}->{SET}->{OBJ}->{'NOV_".$p->{yyvs}->[$p->{yyvsp}-1]."'}->Clone;"); }
-}
-if ($p->{yyn} == 3) {
-{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-0]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-0]."->Complement(".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
-}
-if ($p->{yyn} == 4) {
-{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-0]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-0]."->Complement(".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
-}
-if ($p->{yyn} == 5) {
-{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->ExclusiveOr(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
-}
-if ($p->{yyn} == 6) {
-{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->ExclusiveOr(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
-}
-if ($p->{yyn} == 7) {
-{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Difference(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
-}
-if ($p->{yyn} == 8) {
-{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Difference(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
-}
-if ($p->{yyn} == 9) {
-{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Intersection(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
-}
-if ($p->{yyn} == 10) {
-{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Intersection(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
-}
-if ($p->{yyn} == 11) {
-{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Union(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
-}
-if ($p->{yyn} == 12) {
-{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-2]; push(@OUT, $p->{yyvs}->[$p->{yyvsp}-2]."->Union(".$p->{yyvs}->[$p->{yyvsp}-2].",".$p->{yyvs}->[$p->{yyvsp}-0].");"); }
-}
-if ($p->{yyn} == 13) {
-{ $p->{yyval} = $p->{yyvs}->[$p->{yyvsp}-1]; }
-}
-    $p->{yyssp} -= $p->{yym};
-    $p->{yystate} = $p->{yyss}->[$p->{yyssp}];
-    $p->{yyvsp} -= $p->{yym};
-    $p->{yym} = $yylhs[$p->{yyn}];
-    if ($p->{yystate} == 0 && $p->{yym} == 0)
-    {
-      warn("yydebug: after reduction, shifting from state 0 ",
-            "to state $YYFINAL\n") if $p->{yydebug};
-      $p->{yystate} = $YYFINAL;
-      $p->{yyss}->[++$p->{yyssp}] = $YYFINAL;
-      $p->{yyvs}->[++$p->{yyvsp}] = $p->{yyval};
-      if ($p->{yychar} < 0)
-      {
-        if ((($p->{yychar}, $p->{yylval}) = 
-            &{$p->{yylex}}($s)) < 0) { $p->{yychar} = 0; }
-        if ($p->{yydebug})
-        {
-          $p->{yys} = '';
-          if ($p->{yychar} <= $#yyname) 
-            { $p->{yys} = $yyname[$p->{yychar}]; }
-          if (!$p->{yys}) { $p->{yys} = 'illegal-symbol'; }
-          warn("yydebug: state $YYFINAL, reading " . 
-               $p->{yychar} . " (" . $p->{yys} . ")\n");
-        }
-      }
-      return ($p->{yyvs}->[1]) if $p->{yychar} == 0;
-      next yyloop;
-    }
-    if (($p->{yyn} = $yygindex[$p->{yym}]) && 
-        ($p->{yyn} += $p->{yystate}) >= 0 && 
-        $p->{yyn} <= $#yycheck && 
-        $yycheck[$p->{yyn}] == $p->{yystate})
-    {
-        $p->{yystate} = $yytable[$p->{yyn}];
-    } else {
-        $p->{yystate} = $yydgoto[$p->{yym}];
-    }
-    warn("yydebug: after reduction, shifting from state " . 
-        $p->{yyss}->[$p->{yyssp}] . " to state " . 
-        $p->{yystate} . "\n") if $p->{yydebug};
-    $p->{yyss}[++$p->{yyssp}] = $p->{yystate};
-    $p->{yyvs}[++$p->{yyvsp}] = $p->{yyval};
-  } # yyloop
-} # yyparse
-
-#   create new set variable
-$tmpcnt = 0;
-sub newvar {
-    my ($name) = @_;
-    my ($tmp);
-
-    if ($main::CFG->{SLICE}->{SET}->{OBJ}->{"$name"} eq '') {
-        main::printwarning("no such slice '$name'\n") if $undef;
-        #    The $undef string is caught by caller, it is used
-        #    to trap warnings depending on the -y command line flag.
-        die $undef."\n" if $undef > 1;
-        $main::CFG->{SLICE}->{SET}->{OBJ}->{"$name"} =
-                $main::CFG->{SLICE}->{SET}->{OBJ}->{DEF0}->Clone;
-    }
-    $tmp = sprintf("\$T%03d", $tmpcnt++);
-    return $tmp;
-}
-
-#   the lexical scanner
-sub yylex {
-    local (*s) = @_;
-    my ($c, $val);
-
-    #   ignore whitespaces
-    $s =~ s|^\s+||;
-
-    #   recognize end of string
-    return 0 if ($s eq '');
-
-    #   found a token
-    if ($s =~ s|^([_A-Z0-9*{}]+)||) {
-        $val = $1;
-
-        #   if its a wildcarded slice name we have
-        #   to construct the slice union on-the-fly
-        if ($val =~ m|\*|) {
-            my $pat = $val;
-            $pat =~ s|\*|\.\*|g;
-
-            #   treat special *{...} sequence
-            $excl = '';
-            while ($pat =~ s|^(.*?)\.\*\{([_A-Z0-9]+)\}(.*)$|$1\.\*$3|) {
-                my $temp = $1 . $2 . $3;
-                $temp =~ s|\.\*\{[_A-Z0-9]+\}|\.\*|g;
-                $excl .= "return 1 if m/^$temp\$/;";
-            }
-            $sub_excl = eval "sub { \$_ = shift; $excl; return 0}";
-
-            my $slice;
-            my @slices = ();
-            foreach $slice (keys(%{$main::CFG->{SLICE}->{SET}->{ASC}})) {
-                if ($slice =~ m|^$pat$|) {
-                    push(@slices, $slice) unless &$sub_excl($slice);
-                }
-            }
-            if ($#slices == 0) {
-                $val = $slices[0];
-            }
-            elsif ($#slices > 0) {
-                $s = join('u', @slices).')'.$s;
-                return ord('(');
-            }
-            else {
-                main::printwarning("no existing slice matches `$val'\n") if $wildcard;
-                #    The $wildcard string is caught by caller, it is used
-                #    to trap warnings depending on the -y command line flag.
-                die $wildcard."\n" if $wildcard > 1;
-            }
-        }
-        return ($SLICE, $val);
-    }
-
-    #   else give back one plain character
-    $c = substr($s, 0, 1);
-    $s = substr($s, 1);
-    return ord($c);
-}
-
-#   and error function
-sub yyerror {
-    my ($msg, $s) = @_;
-    die "$msg at $s.\n";
-}
-
-#
-#  The top-level function which gets called by the user
-#
-#  ($cmds, $var) = SliceTerm::Parse($term, $status);
-#
-
-package SliceTerm;
-
-sub Parse {
-    local($str, $status) = @_;
-    my($p, $var, $cmds);
-
-    @SliceTermParser::OUT = ();
-    $SliceTermParser::undef = $status->{u};
-    $SliceTermParser::wildcard = $status->{w};
-    $p = SliceTermParser->new(\&SliceTermParser::yylex, \&SliceTermParser::yyerror, 0);
-    eval {$var = $p->yyparse(*str);};
-    if ($@ =~ s/^(\d)$//) {
-        main::error("Execution stopped\n") if $1 > 2;
-        return ();
-    }
-    $cmds = join("\n", @SliceTermParser::OUT) . "\n";
-
-    return ($cmds, $var);
-}
-
-package main;
-
-1;
-##EOF##
-1;