#!/usr/bin/perl -w
# input file:
#   lines, with one canonical subsegment specification (csss) each
#   (need not be unique)
# output:
#   lines:
#
# B <datumpart> <numbits> <bottombit>
#   ((1u << numbits) - 1) << bottombit is the mask for datumpart
#   datumpart may be Segnum Movfeatpos Edge Angle
#   B lines are right at the start
#
# C <csss> 0x<datum> <angle-bits>
#   where <csss> is N/[M] (see informat.txt) and <datum>
#   is the hex value of the datum (see segcmap.h)
#
# S <segname> 0x<segnum>
# F <segname> 0x<segnum> <featname> 0x<prefix> <configbits>
#      where (1<<configbits)-1 are the bits for the config
#      and ~((1<<configbits)-1) are the bits for the prefix
#
# # comments for debugging segcmapassign etc.
# E
#     final line, always present

use strict;
use IO::Handle;

our ($seg,$movfeat,$movconf,$si,$fi);
our (%seg);

our %bits;

sub read_segcmap_h () {
    my ($p);
    open H, "< segcmap.h" or die $!;
    map { $bits{$_}=0 } qw(Angle Movfeatpos Segnum);
    while (<H>) {
	next unless m/^\#define\s+([A-Z])([A-Z]*)_BITS\s+([1-9]\d*)\s*$/;
	$p= uc($1).lc($2);
	next unless exists $bits{$p};
	die $p if $bits{$p};
	$bits{$p}= $3;
    }
    map { die $_ unless $bits{$_} } keys %bits;
}

read_segcmap_h();

sub pf { printf @_ or die $!; }

pf("B Segnum %d %d\n", $bits{Segnum}, 24-$bits{Movfeatpos}-$bits{Segnum});
pf("B Movfeatpos %d %d\n", $bits{Movfeatpos}, 24-$bits{Movfeatpos});
pf("B Edge %d %d\n", 1, $bits{Angle});
pf("B Angle %d %d\n", $bits{Angle}, 0);

sub cssnmap ($$$$) {
    my ($seg,$movfeat,$segnum,$posinfo) = @_;
    my ($datum);
    $datum=
	($posinfo << (24 - $bits{Movfeatpos})) |
	($segnum << (24 - $bits{Movfeatpos} - $bits{Segnum}));
    pf("C %s/%s 0x%06x %d\n",
       $seg, $movfeat, $datum, $bits{Angle});
}

while (<>) {
    m,^(\w*)/([A-Za-z_]*)(\d*)$, or die;
    ($seg,$movfeat,$movconf)=($1,$2,$3);
    if (!length $seg) {
	die "too many $seg $movfeat" if
	    length $movfeat && $movconf >= $bits{Movfeatpos}-1;
	cssnmap($seg,$movfeat,0,
		length $movfeat ? 1<<($bits{Movfeatpos}-1) : 0);
	next;
    }
    die if length $movconf && !length $movfeat;
    exists $seg{$seg}{Num};
    $si= $seg{$seg};
    if (length $movfeat) {
	exists $si->{Feat}{$movfeat}{Max};
	$fi= $si->{Feat}{$movfeat};
	$fi->{Max}=0 unless exists $fi->{Max};
	$fi->{Max}=$movconf unless $fi->{Max} >= $movconf;
    }
}

our ($segnum) = 1;

our ($posbit,$posbiti,$abovenext);

foreach $seg (sort keys %seg) {
    $si= $seg{$seg};
    $si->{Num}= $segnum++;
    die if $si->{Num} >= 1 << $bits{Segnum};
    $abovenext= 1 << $bits{Movfeatpos};
    pf("S %s 0x%x\n",
       $seg, $si->{Num});
    cssnmap($seg,'', $si->{Num}, 0x00);
    foreach $movfeat (sort {
	$si->{Feat}{$b}{Max} <=> $si->{Feat}{$a}{Max};
    } keys %{ $si->{Feat} }) {
	$fi= $si->{Feat}{$movfeat};
	$posbiti= $fi->{Max}+1;
	$posbit= 1<<$posbiti;
	$abovenext -= $posbit;
	die "too many $seg" if $abovenext <= 0;
	$fi->{Prefix}= $abovenext;
	$fi->{ConfigMask}= $posbit-1;
	$fi->{ConfigBits}= $posbiti;
        pf("F %s 0x%x %s 0x%x %d\n",
	   $seg, $si->{Num},
	   $movfeat, $fi->{Prefix}, $fi->{ConfigBits});
	cssnmap($seg, $movfeat, $si->{Num}, $fi->{Prefix});
    }
}

STDIN->error and die $!;
print "E\n" or die $!;