#!/usr/local/bin/perl
# -*- perl -*-

sub usage {
    print <<USAGE;

re - run a regular expression on an input

Usage
  re [-h] [-v] regular_expression input_string

  The regular_expression is a regular expression using the syntax of
  the Linz book.  Use % for lambda and @ for empty set.  It is usually
  best to enclose this string in single quotes.  No error checking is
  performed.  This program returns yes (the input_string matches the
  regular_expression) or no.
  
  For example, the following command determines whether the
  input_string contains an even number of a's and b's.

      re '((a+b)(a+b))*' abaabbabbba

  The -h option will print this help and exit.

  The -v option will print the transitions of the NFA that is created.

USAGE
    exit;
}



use Getopt::Std;

getopts("hv");

usage() if ($opt_h);


$parendepth = 0;
$lambda = "%";
$nextstate = 0;

sub newstate {
    return $nextstate++;
}

sub addtransition {
    my ($state1, $symbol, $state2) = @_;
    push(@{$next_state{$state1}{$symbol}}, $state2);
}


sub parse {
    # $pos is the current position in the regular_expression string
    # $initial is the initial state of the nfa that this procedure creates
    # $final is the final state of the nfa
    my ($pos,$initial,$final) = @_;
    
    my ($sym, $subinit, $subfinal, $starpoint, $current);

    $current = newstate();
    addtransition($initial, $lambda, $current);
    $starpoint = $current;

    while ($pos < length($re)) {

	# get the next symbol in the regular expression
	$sym = substr($re,$pos,1);
	$pos++;
	next if $sym eq " ";

	if ($sym eq "\\" && $pos < length($re)) {
	    $sym = substr($re,$pos,1);
	    $pos++;
	} 

	if ($sym eq ")") {
	    $parendepth--;
	    addtransition($current, $lambda, $final);
	    return $pos;
	}
	elsif ($sym eq "(") {
	    $parendepth++;
	    $subinit = newstate();
	    $subfinal = newstate();	
	    $pos = parse($pos, $subinit, $subfinal);
	    addtransition($current, $lambda, $subinit);
	    $starpoint = $subinit;
	    $current = $subfinal;
	    
	}
	elsif ($sym eq "+") {
	    addtransition($current, $lambda, $final);
	    $current = newstate();
	    addtransition($initial, $lambda, $current);
	    $starpoint = $current;
	}
	elsif ($sym eq "*") {
	    if ($starpoint != $current) {
		$subfinal = newstate();
		addtransition($current, $lambda, $subfinal);
		addtransition($starpoint, $lambda, $subfinal);
		addtransition($subfinal, $lambda, $starpoint);
		$current = $subfinal;
		$starpoint = $subfinal;
	    }
	}
	elsif ($sym eq "@") {
	    $current = newstate();
	    $starpoint = newstate();
	}
	else {
	    $starpoint = newstate();
	    addtransition($current, $lambda, $starpoint);
	    $subfinal = newstate();
	    addtransition($starpoint, $sym, $subfinal);
	    $current = $subfinal;
	}
    }
    addtransition($current, $lambda, $final);
    return $pos;
}

sub transition {
    my $symbol = shift;
    my @stateset = @_;
    my @nextset;
    @nextset = @stateset if $symbol eq $lambda; # for lambda transitions
    my ($i, $state1, $state2, $j);
    for ($i = 0; $i <= $#stateset; $i++) {
	$state1 = $stateset[$i];
	foreach $state2 (@{$next_state{$state1}{$symbol}}) {
	    for ($j = 0; $j <= $#nextset && $state2 ne $nextset[$j]; $j++) {};
	    if ($j > $#nextset) {
		push(@nextset, $state2);
		push(@stateset, $state2) if $symbol eq $lambda;
	    }
	}
    }
    return @nextset;
}


usage() unless $#ARGV == 0 || $#ARGV == 1;

$re = $ARGV[0];
$string = $ARGV[1];

# create NFA from $re
$initial_state = newstate();
$final_state = newstate();
parse(0, $initial_state, $final_state);

# initialize input and NFA
for ($i = 0; $i < length($string); $i++) {
    $input[$i] = substr($string,$i,1);
}
@stateset = transition($lambda, $initial_state);

if ($opt_v) {
    print("Input\tState(s)\n");
    print("-----\t--------\n");
    printf "\t%s\n", join(", ", @stateset);
}

for ($position = 0; $position <= $#input; $position++) {

    # perform transition
    @stateset = transition($input[$position], @stateset);
    @stateset = transition($lambda, @stateset);

    if ($opt_v) {
	printf "  %s\t%s\n", $input[$position], join(", ", @stateset);
    }
}

$matched = 0;
for ($i = 0; $i <= $#stateset; $i++) {
    $matched = 1 if (1 == $stateset[$i]);
}
printf "yes\n" if $matched == 1;
printf "no\n" if $matched == 0;