layout/plan-to-gui-data

   1 #!/usr/bin/perl -w
   2 #
   3 # We make one set of xpms for every (segment,[movfeat])
   4 # For each (segment,[movfeat]) there is one `off' bitmap, a mask.
   5 # For (segment,nil) there are also `on' and `detect' pixmaps.
   6 # For (segment,movfeat) there are `on' and `detect' XPMs for each posn.
   7 # (The `on' and `detect' XPMs share the actual pixel data.)
   8
   9 use strict qw(vars);
  10 use POSIX;
  11 use IO::Handle;
  12
  13 #---------- general ----------
  14
  15 sub seteq ($$$) {
  16     my ($r,$v,$w)= @_;
  17     if (defined $$r) {
  18         $$r eq $v or die "$v $$r $w ?";
  19     } else {
  20         $$r= $v;
  21     }
  22 }
  23
  24 #---------- word-reading (for pbm) ----------
  25
  26 our $txtrdbuf= '';
  27
  28 sub w () {
  29     for (;;) {
  30         if ($txtrdbuf =~ s/^\s*(\S+)\s?//) {
  31 #print STDERR "w>$1<\n";
  32             return $1;
  33         }
  34         $!=0; $txtrdbuf=<>;
  35         die $! unless length $txtrdbuf;
  36         $txtrdbuf='' if $txtrdbuf =~ m/^\s*\#/;
  37     }
  38 }
  39
  40 sub wn ($$) {
  41     my ($wn);
  42     $wn= w();
  43     die "$wn ?" unless $wn =~ m/^(?:[1-9]\d*|0)$/;
  44     die "$wn $_[0]..$_[1] ?" if $wn < $_[0] || $wn > $_[1];
  45     return $wn;
  46 }
  47 sub wns ($$$) {
  48     my (@wns);
  49     while (@wns < $_[2]) { push @wns, wn($_[0],$_[1]); }
  50     return @wns;
  51 }
  52
  53 #---------- xpm data structure ----------
  54
  55 our(%xpmdata);
  56 # $xpmdata{$style}{$namerhs}{X}{Min}
  57 # $xpmdata{$style}{$namerhs}{X}{Max}
  58 # $xpmdata{$style}{$namerhs}{Y}{Min}
  59 # $xpmdata{$style}{$namerhs}{Y}{Max}
  60 # $xpmdata{$style}{$namerhs}{Pixels}{$y}{$x}
  61 # $xpmdata{$style}{$namerhs}{Holey}
  62 # $xpminstance{$instancename}{Data}= $xpmname
  63
  64 sub xpmdata_setup ($$$) {
  65     my ($style, $namerhs, $holey)=@_;
  66     my ($xp,$xy);
  67     die if $xpmdata{$style}{$namerhs};
  68     $xp= $xpmdata{$style}{$namerhs}= {
  69         Holey => $holey,
  70         };
  71 }
  72
  73 #---------- parse args ----------
  74
  75 our $gvarname= 'ui_plan_data';
  76
  77 die unless @ARGV;
  78 die if $ARGV[0] =~ m/^\-/;
  79 if ($ARGV[$#ARGV] =~ s/^\-g//) {
  80     $gvarname= pop @ARGV;
  81     $gvarname =~ s/\W/_/g;
  82 }
  83
  84 #---------- read segcmap ----------
  85
  86 our (%datum_numbits,%datum_basebit);
  87 # $datum_numbits{Segname} etc.
  88
  89 our (@segnum_name,%movfeats,%movfeat_prefix,%movfeat_configbits);
  90 # $segnum_name[$segnum]= $segname;
  91 # $movfeats{$segname}[$i]= $xpmname
  92 # $movfeat_prefix{$xpmname}
  93 # $movfeat_configbits{$xpmname}
  94
  95 xpmdata_setup('background','',1);
  96
  97 for (;;) {
  98     $!=0; defined($_=<>) or die $!;
  99 #print STDERR "p>$_<\n";
 100     last if m/^E$/;
 101     if (m/^B (\w+) (\d+) (\d+)$/) {
 102         $datum_numbits{$1}= $2;
 103         $datum_basebit{$1}= $3;
 104     } elsif (m/^S ([0-9A-Z]+) (0x[0-9a-f]+)$/) {
 105         seteq(\$segnum_name[hex $2], $1, "segnum $2");
 106         xpmdata_setup("bitmap","m_$1",1);
 107         xpmdata_setup("on","_$1",1);
 108         xpmdata_setup("bitmap","e_$1",1);
 109     } elsif (m/^F ([0-9A-Z]+) (0x[0-9a-f]+) ([A-Z]+) (0x[0-9a-f]+) (\d+)$/) {
 110         my ($xpmname,$bitno,$namerhs);
 111         seteq(\$segnum_name[hex $2], $1, "segnum $2 F $3");
 112         push @{ $movfeats{$1} }, $3;
 113         $xpmname= $1.'_'.$3;
 114         $movfeat_prefix{$xpmname}= hex $4;
 115         $movfeat_configbits{$xpmname}= $5;
 116         xpmdata_setup("on","u_$xpmname",1);
 117         xpmdata_setup("bitmap","m_$xpmname",1);
 118         for ($bitno=0; $bitno<$movfeat_configbits{$xpmname}; $bitno++) {
 119             $namerhs= "${xpmname}_${bitno}";
 120             xpmdata_setup("on","_$namerhs",1);
 121             xpmdata_setup("bitmap","e_$namerhs",1);
 122         }
 123     }
 124 }
 125
 126 sub ang2pixchars ($) {
 127     die if $datum_numbits{Angle} > 6;
 128     die if $_[0] > 64;
 129     return substr('0123456789'.
 130                   'abcdefghijklmnopqrstuvwxyz'.
 131                   'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.
 132                   '@#',
 133                   $_[0], 1);
 134 }
 135
 136 #---------- read input image ----------
 137
 138 our(%sz,%overall);
 139 # $sz{X}
 140 # $sz{Y}
 141 # $overall{X|Y}{Min|Max}
 142
 143 sub xpm_sizes () {
 144     my ($rr,$xp,$xy);
 145 print STDERR "xpm_sizes\n";
 146     foreach $rr (values %xpmdata) {
 147         foreach $xp (values %$rr) {
 148             foreach $xy (qw(X Y)) {
 149                 $xp->{$xy}{Min}= $sz{$xy}-1;
 150                 $xp->{$xy}{Max}= 0;
 151             }
 152         }
 153     }
 154     foreach $xy (qw(X Y)) {
 155         $overall{$xy}{Min}= $sz{$xy}-1;
 156         $overall{$xy}{Max}= 0;
 157     }
 158 }
 159
 160 #---------- read input pixels ----------
 161
 162 our(%p,$pp);
 163 # $p{X}
 164 # $p{Y}
 165 # $p{Movpos}
 166
 167 sub xpmdata_pixel ($$$) {
 168     my ($style,$namerhs,$pcharstr)=@_;
 169     my ($xp,$pk,$xy,$was,$mima);
 170 #printf STDERR "%s  %s %s \`%s'", $pp, $style, $namerhs, $pcharstr;
 171     $xp= $xpmdata{$style}{$namerhs};
 172     defined $xp or die "$pp: $style $namerhs ?";
 173     foreach $xy (qw(X Y)) {
 174         foreach $mima ($xp->{$xy}, $overall{$xy}) {
 175             $mima->{Min}= $p{$xy} if $p{$xy} < $mima->{Min};
 176             $mima->{Max}= $p{$xy} if $p{$xy} > $mima->{Max};
 177         }
 178     }
 179     $was= $xp->{Pixels}{$p{Y}}{$p{X}};
 180     if (defined($was) && $was gt $pcharstr) {
 181 #print STDERR " already \`$was'\n";
 182         return;
 183     }
 184 #    die "$pp $style $namerhs \`$pcharstr',\`$xp->{Pixels}{$p{Y}}{$p{X}}' ?"
 185 #
 186     $xp->{Pixels}{$p{Y}}{$p{X}}= $pcharstr;
 187 #print STDERR " set\n";
 188 }
 189
 190 sub in_pixel ($) {
 191     my ($pbytes) = @_;
 192     my ($namerhs,$movfeat,%t,$xpmname,$segname,$datum,$k,$angstr,$bitno,$me);
 193     $pp= "$ARGV $p{X} $p{Y}";
 194     $datum= unpack 'V', $pbytes."\0";
 195     foreach $k (keys %datum_numbits) {
 196         $t{$k}= ($datum >> $datum_basebit{$k}) &
 197             ((1 << $datum_numbits{$k}) - 1);
 198     }
 199 #printf(STDERR "%s 0x%08lx 0x%x 0x%x %d\n",$pp,$datum,
 200 #       $t{Segnum},$t{Movfeatpos},$t{Edge});
 201     if (!$t{Segnum}) {
 202         xpmdata_pixel('background','','=')
 203             unless $t{Edge};
 204         return;
 205     } else {
 206         xpmdata_pixel('background','','!')
 207             unless $t{Edge};
 208     }
 209     $segname= $segnum_name[$t{Segnum}];
 210     defined $segname or die "$pp $t{Segnum} $datum";
 211     $pp.= " $segname";
 212
 213     $angstr= ang2pixchars($t{Angle});
 214
 215     if (!$t{Movfeatpos}) {
 216         $xpmname= $segname;
 217         xpmdata_pixel("on","_$xpmname", $angstr)
 218             unless $t{Edge};
 219         xpmdata_pixel("bitmap", "e_${xpmname}", '*')
 220             if $t{Edge};
 221         xpmdata_pixel("bitmap", "m_${segname}", '*');
 222     } else {
 223         my ($found, $yes);
 224         $found= undef;
 225         foreach $movfeat (@{ $movfeats{$segname} }) {
 226             $xpmname= $segname.'_'.$movfeat;
 227             if (($t{Movfeatpos} & ~((1<< $movfeat_configbits{$xpmname})-1))
 228                 == $movfeat_prefix{$xpmname}) {
 229                 die "$pp $t{Movfeatpos} $found $movfeat"
 230                     if defined $found;
 231                 $found= $movfeat;
 232             }
 233         }
 234         die "$pp $t{Movfeatpos}"
 235             unless defined $found;
 236         $xpmname= $segname.'_'.$found;
 237         xpmdata_pixel("on", "u_${xpmname}",
 238                       (($p{X} + $p{Y}) % 2) ? $angstr : '!')
 239             unless $t{Edge};
 240         xpmdata_pixel("bitmap", "m_${xpmname}", '*');
 241         for ($bitno=0; $bitno < $movfeat_configbits{$xpmname}; $bitno++) {
 242             $namerhs= "${xpmname}_${bitno}";
 243             $yes= $p{Movpos} == $bitno;
 244             xpmdata_pixel("on","_$namerhs", $yes ? $angstr : '!')
 245                 unless $t{Edge};
 246             xpmdata_pixel("bitmap","e_$namerhs", $yes ? '*' : ' ')
 247                 if $t{Edge};
 248         }
 249     }
 250 }
 251
 252 #---------- read input pixmaps
 253
 254 sub read_pixmap_header () {
 255     my (@szn,$osz);
 256     @szn= wns(1,32767,2);
 257     if (exists $sz{X}) {
 258         $osz= "$sz{X} $sz{Y}";
 259         "@szn" eq "$osz" or die "$osz @szn ?";
 260     } else {
 261         ($sz{X},$sz{Y})= @szn;
 262         xpm_sizes();
 263     }
 264     wn(1,65535)==255 or die;
 265 }
 266
 267 for (;;) {
 268     die "$txtrdbuf ?" if length $txtrdbuf;
 269     $txtrdbuf= <>;
 270     if (!defined $txtrdbuf) {
 271         die $! unless ARGV->eof;
 272         last;
 273     }
 274     w() eq 'P6' or die;
 275     read_pixmap_header();
 276     $ARGV =~ m/.*\.p([0-9a-f]+)\b/ or die "$ARGV ?";
 277     $p{Movpos}= $1 eq 'f' ? '' : hex($1);
 278     my ($pbytes,$x,$xsz);
 279     $xsz= $sz{X};
 280     for ($p{Y}=0; $p{Y}<$sz{Y}; $p{Y}++) {
 281         printf STDERR "%s %d\r",$ARGV,$p{Y}
 282             unless $p{Y} % 100;
 283         for ($x=0; $x<$xsz; $x++) {
 284             $!=0; read(ARGV, $pbytes, 3) == 3 or die $!;
 285             next if $pbytes eq "\xff\xff\xff";
 286             $p{X}= $x;
 287             in_pixel($pbytes);
 288         }
 289     }
 290 }
 291
 292 #---------- colourmaps ----------
 293
 294 our (%cmap,%stylecmaps);
 295 # $stylecmaps{$style}= [ $cmapname,... ]
 296 # $cmap{$cmapname}{$pixchars}= $xpm_data_string_rhs
 297 # $cmap{$cmapname}{''}= [ string names for including in xpm ]
 298 #                          (after cmapdata_output_all)
 299 $cmap{''}= {}; # fixed colours
 300
 301 sub xpm_cmap ($$) {
 302     my ($style,$cmapname) = @_;
 303     die "$cmapname ?" if exists $cmap{$cmapname};
 304     push @{ $stylecmaps{$style} }, $cmapname;
 305     $cmap{$cmapname}= { };
 306 }
 307
 308 sub xpm_cmap_entry ($$$) {
 309     my ($cmapname,$pixchars,$rhs) = @_;
 310     die "$cmapname ?" unless exists $cmap{$cmapname};
 311     die "$cmapname $pixchars ?" if exists $cmap{$cmapname}{$pixchars};
 312     $cmap{$cmapname}{$pixchars}= $rhs;
 313 }
 314
 315 sub xpm_cmap_rgbpermil($@) {
 316     my ($cmapname, @l) = @_;
 317     my ($pixchars, @rgb);
 318     die "$cmapname @l ?" if @l % 4;
 319     while (@l) {
 320         ($pixchars, @rgb)= @l[0..3];  @l = @l[4..$#l];
 321         xpm_cmap_entry($cmapname, $pixchars,
 322                        sprintf("c #%04x%04x%04x",
 323                                map { floor($_ * 65.535 + 0.5) } @rgb));
 324     }
 325 }
 326
 327 sub xpm_cmap_fixedbitmap($$) {
 328     my ($cmapname,$on) = @_;
 329     xpm_cmap_entry($cmapname,' ','s space');
 330     xpm_cmap_entry($cmapname,$on,'s mark');
 331 }
 332
 333 sub angle_to_colour ($) {
 334     my ($angle) = @_;
 335     my ($s,$f,$u,$U,$d,$D,$R);
 336
 337     $s= floor($angle);
 338     $f= $angle - $s;
 339
 340     $u= $f * 0.5;
 341     $U= $u + 0.5;
 342     $d= 0.5 - $u;
 343     $D= $d + 0.5;
 344
 345 #print STDERR "a>$u|$U|$d|$D|$s<\n";
 346
 347     $R= ([ $D, $U,  0 ],
 348          [ $d,  1, $u ],
 349          [  0, $D, $U ],
 350          [ $u, $d,  1 ],
 351          [ $U,  0, $D ],
 352          [  1, $u, $d ])[$s];
 353     $R->[1] *= 0.9;
 354     $R->[2] *= 0.9;
 355     return @$R;
 356 }
 357
 358 sub xpm_cmap_angular($$$@) {
 359     my ($cmapname, $invert, $alpha, @basergb) = @_;
 360     my ($angnum,$angval,@permil,@angrgb,$i);
 361     for ($angnum=0; $angnum<(1<<$datum_numbits{Angle}); $angnum++) {
 362         $angval= 6.0 * ($angnum+0.0) / (1<<$datum_numbits{Angle});
 363         $angval += 3.0 if $invert;
 364         $angval -= 6.0 if $angval >= 6.0;
 365         @angrgb= angle_to_colour($angval);
 366         for ($i=0; $i<3; $i++) {
 367 #print STDERR ">$cmapname|$i|$alpha|$angrgb[$i]|$basergb[$i]<\n";
 368             $permil[$i]= $alpha * $angrgb[$i] +
 369                          (1.0 - $alpha/1000.0) * $basergb[$i];
 370         }
 371         xpm_cmap_rgbpermil($cmapname, ang2pixchars($angnum), @permil);
 372     }
 373 }
 374
 375 sub cmaps_define () {
 376     my ($style,$inv,$ondet);
 377     my (@background, @projected, @off, @otherposn);
 378
 379     @background= qw(100 100 100);
 380     @off= qw(0 0 0);
 381     @otherposn= qw(50 50 50);
 382     @projected= qw(75 75 75);
 383
 384     xpm_cmap("background","background");
 385     xpm_cmap_rgbpermil("background",
 386                        ' ', @background,
 387                        '=', @projected,
 388                        '!', @off);
 389
 390     xpm_cmap("bitmap","bitmap");
 391     xpm_cmap_fixedbitmap("bitmap",'*');
 392
 393     foreach $inv (('','i')) {
 394         foreach $ondet (qw(on det)) {
 395             xpm_cmap("on","${inv}${ondet}");
 396             xpm_cmap_rgbpermil("${inv}${ondet}",
 397                                ' ', @background,
 398                                '!', @otherposn);
 399         }
 400         xpm_cmap_angular("${inv}on", !!$inv, 650, qw(0 0 0));
 401         xpm_cmap_angular("${inv}det",!!$inv, 650, qw(1000 1000 1000));
 402     }
 403 }
 404
 405 cmaps_define();
 406
 407 #---------- output ----------
 408
 409 sub cmapdata_output_all () {
 410     my ($cmapname, $stuff, $cmap, $sname, $pixchars);
 411
 412     foreach $cmapname (sort keys %cmap) {
 413         next unless length $cmapname;
 414         $stuff= [ ];
 415         $cmap= $cmap{$cmapname};
 416         foreach $pixchars (sort keys %$cmap) {
 417             $sname= "m_${cmapname}_". unpack "H*", $pixchars;
 418             printf("static const char %s[]= \"%s %s\";\n",
 419                    $sname, $pixchars, $cmap->{$pixchars})
 420                 or die $!;
 421             push @$stuff, $sname;
 422         }
 423         $cmap->{''}= $stuff;
 424     }
 425
 426     my ($colour, $rhs);
 427     $cmap= $cmap{''};
 428     foreach $colour (sort keys %$cmap) {
 429         $rhs= $cmap->{$colour};
 430         $rhs =~ s/^c // or die "$colour $rhs ?";
 431         printf("const char ui_plan_colour_%s[]= \"%s\";\n",
 432                $colour, $rhs)
 433             or die $!;
 434     }
 435 }
 436
 437 sub xpmdata_output_all () {
 438     my ($style, $namerhs, $xp, $row, $pp, $xy, $pixel);
 439     my ($y, $cmap_data, $header_data, $cmapname);
 440     foreach $style (sort keys %xpmdata) {
 441         foreach $namerhs (sort keys %{ $xpmdata{$style} }) {
 442             $xp= $xpmdata{$style}{$namerhs};
 443             $header_data= "";
 444             foreach $xy (qw(X Y)) {
 445                 $xp->{$xy}{Max}= $xp->{$xy}{Min} if
 446                     $xp->{$xy}{Max} < $xp->{$xy}{Min};
 447                 $header_data .= $xp->{$xy}{Max} - $xp->{$xy}{Min} + 1;
 448                 $header_data .= " ";
 449             }
 450             for ($p{Y}=$xp->{Y}{Min}; $p{Y}<=$xp->{Y}{Max}; $p{Y}++) {
 451                 printf "static const char d%04d_%s_%s[]= \"",
 452                     $p{Y}, $style, $namerhs or die $!;
 453                 $row= $xp->{Pixels}{$p{Y}};
 454                 $pp= "$style $namerhs $p{X} $p{Y}";
 455                 for ($p{X}=$xp->{X}{Min}; $p{X}<=$xp->{X}{Max}; $p{X}++) {
 456                     $pixel= $row->{$p{X}};
 457                     if (!defined $pixel) {
 458                         die "$pp ?" if !$xp->{Holey};
 459                         $pixel= ' ';
 460                     }
 461                     print $pixel or die $!;
 462                 }
 463                 print "\";\n" or die $!;
 464             }
 465 #printf STDERR "style >$style<\n";
 466             foreach $cmapname (sort @{ $stylecmaps{$style} }) {
 467                 $cmap_data= $cmap{$cmapname}{''};
 468                 printf("static const char *p_%s_%s[]= {\n".
 469                        "  \"%s%d 1\",\n",
 470                        $cmapname, $namerhs,
 471                        $header_data, scalar(@$cmap_data))
 472                     or die $!;
 473                 map { printf "  %s,\n", $_ or die $!; } @$cmap_data;
 474                 for ($y=$xp->{Y}{Min}; $y<=$xp->{Y}{Max}; $y++) {
 475                     printf "  d%04d_%s_%s,\n", $y, $style, $namerhs
 476                         or die $!;
 477                 }
 478                 print("  0\n".
 479                       "};\n")
 480                     or die $!;
 481             }
 482         }
 483     }
 484 }
 485
 486 sub ppdr ($$$) {
 487     my ($style,$cmap,$namerhs) = @_;
 488     my ($xpmd);
 489     $xpmd= $xpmdata{$style}{$namerhs};
 490 defined $xpmd or die "$style $cmap $namerhs ?";
 491     return sprintf("{ %d-%d,%d-%d, p_%s_%s }",
 492                    (map { $xpmd->{$_}{Min}, $overall{$_}{Min} } qw(X Y)),
 493                    $cmap, $namerhs);
 494 }
 495
 496 sub ppdiondet ($) {
 497     my ($dname) = @_;
 498     return ("{ { ".ppdr('on',"on",$dname).", ".ppdr('on',"det",$dname)." },".
 499             " { ".ppdr('on',"ion",$dname).", ".ppdr('on',"idet",$dname).
 500             " } }");
 501 }
 502
 503 our (@oodnames, %ood);
 504 # $ood{$oodname}{Data}= $data_so_far
 505 # $ood{$oodname}{ArrayDelim}= "\n" or ",\n" but for oodas only
 506
 507 sub oods ($$) {
 508     my ($oodname, $data) = @_;
 509     die "$oodname {{$data}} ?" if exists $ood{$oodname};
 510     $ood{$oodname}{Data}= $data;
 511     push @oodnames, $oodname;
 512 }
 513
 514 sub ooda0 ($$) {
 515     my ($oodname, $begin) = @_;
 516     die "$oodname {{$begin}} ?" if exists $ood{$oodname};
 517     $ood{$oodname}{Data}= $begin;
 518     $ood{$oodname}{Data} .= "[]= {";
 519     $ood{$oodname}{ArrayDelim}= "\n";
 520     push @oodnames, $oodname;
 521 }
 522
 523 sub ooda1 ($$) {
 524     my ($oodname, $entry) = @_;
 525     die "$oodname {{$entry}} ?" unless defined $ood{$oodname}{ArrayDelim};
 526     $ood{$oodname}{Data} .= $ood{$oodname}{ArrayDelim};
 527     $ood{$oodname}{Data} .= "  ".$entry;
 528     $ood{$oodname}{ArrayDelim}= ",\n";
 529 }
 530
 531 sub ood_output_all () {
 532     my ($oodname, $ood);
 533     foreach $oodname (reverse @oodnames) {
 534         $ood= $ood{$oodname};
 535         print $ood->{Data} or die $!;
 536         if (defined $ood->{ArrayDelim}) {
 537             print "\n};\n" or die $!;
 538         }
 539     }
 540 }
 541
 542 sub plandata_output_all () {
 543     my ($i, @segnames, $segname);
 544     my (@movfeats, $movfeat, $dname, $xpmname, $n_posns, $code, $posn);
 545     my ($n_movfeats, $style, $xpmd, $pedge, $me, $noppdr);
 546
 547     for ($i=1; $i<@segnum_name; $i++) {
 548         $segname= $segnum_name[$i];
 549         next unless defined $segname;
 550         push @segnames, $segname;
 551     }
 552
 553     oods('ui_plan_data',
 554          "const PlanData $gvarname= {\n".
 555          "  $overall{X}{Max}-$overall{X}{Min},".
 556          "  $overall{Y}{Max}-$overall{Y}{Min},".
 557          "  p_background_,\n".
 558          "  ".scalar(@segnames).", segments\n".
 559          "};\n");
 560
 561     ooda0('segments',
 562           "static const PlanSegmentData segments");
 563
 564     foreach $segname (sort @segnames) {
 565         @movfeats=
 566             exists $movfeats{$segname} ? @{ $movfeats{$segname} } : ();
 567         unshift @movfeats, '';
 568
 569         ooda0("mf_$segname",
 570               "static const PlanSegmovfeatData mf_$segname");
 571
 572         ooda1("segments",
 573               "{ \"$segname\", ".scalar(@movfeats).", mf_$segname }");
 574
 575         foreach $movfeat (sort @movfeats) {
 576             if (!length $movfeat) {
 577                 $xpmname= $segname;
 578                 $n_posns= 1;
 579                 $code= '0';
 580             } else {
 581                 $xpmname= "${segname}_${movfeat}";
 582                 $n_posns= $movfeat_configbits{$xpmname};
 583                 $code= "\"$movfeat\"";
 584             }
 585 #print STDERR ">$segname|$movfeat<\n";
 586             $noppdr= "{-1,-1,0}";
 587             ooda1("mf_$segname",
 588                   "{ $code, ".ppdr('bitmap',"bitmap","m_$xpmname").", ".
 589                   ($n_posns > 1 ? ppdiondet("u_$xpmname") :
 590                    "{ { $noppdr, $noppdr }, { $noppdr, $noppdr } }").
 591                   ", $n_posns, posns_$xpmname }");
 592
 593             ooda0("posns_$xpmname",
 594                   "static const PlanPixmapOnData posns_$xpmname");
 595
 596             for ($posn=0; $posn < $n_posns; $posn++) {
 597                 if ($movfeat eq '') {
 598                     $dname= $segname;
 599                     $pedge= 'edge';
 600                 } else {
 601                     $dname= sprintf "%s_%s_%d", $segname, $movfeat, $posn;
 602                     $pedge= 'pedge';
 603                 }
 604                 ooda1("posns_$xpmname",
 605                       "{ ".ppdr('bitmap',"bitmap","e_$dname").",".
 606                       " ".ppdiondet("_$dname")." }");
 607             }
 608         }
 609     }
 610 }
 611
 612 print "#include \"plan-data-format.h\"\n" or die $!;
 613 cmapdata_output_all();
 614 xpmdata_output_all();
 615 plandata_output_all();
 616 ood_output_all();