elex

用于词法分析的词法分析器

#!/usr/local/bin/perl

# $Id: elex,v 1.13 1997/04/20 02:14:50 matt Exp $
#
# Elex front end.
#
# (c) June 1996 Matt Phillips.

BEGIN
{
  # extract root dir from exec path
  ($root) = ($0 =~ m<^(.*)/[^/]*$>);
  $root = '.' if !$root;

  # set @INC correctly
  if (-d "$root/foo")
  {
    # development configuration
    push (@INC, "$root/foo");
    $configFile = "$root/elex.cfg";
  } else
  {
    # installed configuration
    $root = "$root/..";
    push (@INC, "$root/lib/foo");
    $configFile = "$root/lib/elex.cfg";
  }

  push (@INC, "$root/util");
}

use FooParser;
use FooObject;
use File::Basename;
use Getopt::Std;
use StdApp;

#----------------------------------------------------------------------
# defines

$usage =
'
  Usage: elex [options] <file>

    <file> is either an Elex scanner (.elx) or an Elex scanner
    definition (.esd) generated by using Elex with the \'-c\' option.

  Options:
    -c           compile only (generate .esd and .ecf)
    -l language  set language for scanner
    -d           run debugger
    -v           verbose mode
    -V           display Elex version

';

#----------------------------------------------------------------------
# subs

sub deleteTempFiles
{
  for (@tempFiles)
  {
    unlink ($_);
  }

  @tempFiles = ();

  return 1;
}

# make path into absolute by adding $root to the start if the path is
# not already absolute.
sub makeAbsolutePath
{
  my $path = shift;

  if (!($path =~ m<^/>))
  {
    $path = "$root/$path";
  }

  return $path;
}

# work out the 'default' (ie. first mentioned) language from codefrags
# file.
sub divineLanguage
{
  my $codeFrags = shift;
  my $language;

  say ("scanning $codeFrags for default language");

  open ($codeFrags, $codeFrags) || return undef;

  while (($_ = <$codeFrags>) && !$language)
  {
    if (/^*/)
    {
      $_ = <$codeFrags>;
      chomp;

      if (!/^[>*]/ && $_ ne '')
      {
	$language = $_;
      }
    }
  }

  # if we failed to divine the language, then use the default from
  # config.
  if (!$language)
  {
    $language = $config->getAttrStringPath ('codegen/default');
  }

  say ("language is '$language'");

  close ($codeFrags);
  return $language;
}

sub elexToScannerDef
{
  my ($elxFile) = shift;
  my $esdFile = "/tmp/elex$$.esd";
  my $ecfFile = "/tmp/elex$$.ecf";
  my $compiler = makeAbsolutePath ($config->getAttrString ('compiler'));

  push (@tempFiles, $esdFile);
  push (@tempFiles, $ecfFile);

  systemExec (eval ("\"$compiler\""), "compile failed");

  return ($esdFile, $ecfFile);
}

sub scannerDefToCode
{
  my ($esdFile, $ecfFile, $scannerBase) = @_;
  my $outputBase = "/tmp/elex$$";
  my $language = $opt_l ? $opt_l : divineLanguage ($ecfFile);
  my $outputFiles = $config->getAttrsPath ("codegen/generators/$language/outputs");
  my $codeGenerator =
    $config->getAttrStringPath ("codegen/generators/$language/exec");

  if ($language)
  {
    if ($codeGenerator)
    {
      # build output file list
      for (@{$config->getAttrsPath ("codegen/generators/$language/outputs")})
      {
	my $file = $_->getAttr ();
	$file = eval ("\"$file\"");
	push (@outputFiles, $file);
	push (@tempFiles, $file);
      }

      # expand variables in codeGenerator
      $codeGenerator = eval ("\"$codeGenerator\"");
      if (!$codeGenerator)
      {
	error ("invalid code generator exec for '$language'");
      } else
      {
	systemExec (makeAbsolutePath ($codeGenerator));
      }
    } else
    {
      error ("no code generator for language '$language'");
    }
  } else
  {
    error ("cannot guess language: specify using '-l' option");
  }

  return @outputFiles;
}

sub debugScannerDef
{
  my $esdFile = shift;
  my $debugger = $config->getAttrString ("debug");

  error ("no debugger available") if !$debugger;

  $debugger = eval ("\"$debugger\"");

  if ($debugger)
  {
    systemExec (makeAbsolutePath ($debugger));
  } else
  {
    error ("error in debug setting");
  }
}

sub copyOutfiles
{
  my ($base, @files) = @_;
  my $file;

  for $file (@files)
  {
    my $fileExt = (fileparse ($file, '\..*')) [2];
    my $targetFile = "$base$fileExt";
    systemExec ("/bin/cp $file $targetFile 2> /dev/null 1> /dev/null",
		"could not create $targetFile");
  }
}

#----------------------------------------------------------------------
# main

addCleanup ('deleteTemps', \&deleteTempFiles);

# check command line
if (!getopts ('cl:vdV') || (!$opt_V && $#ARGV != 0))
{
  print STDERR ($usage);
  exit (1);
}

$file = $ARGV [0];
($fileName, $filePath, $fileExt) = (fileparse ($file, '\..*'));
$fileBase = "$filePath$fileName";

# read config
open (CONFIG, $configFile) || error ("could not open $configFile: $!");

$parser = new FooParser (\*CONFIG);
close (CONFIG);

if ($parser->getErrors ())
{
  error ("problems parsing $configFile:\n".
	 join ("\n ", @{$parser->getErrors ()})."\n");
}

$config = $parser->getRoot ();

# check for version option
if ($opt_V)
{
  print ("Elex version ".$config->getAttrString ('version'), "\n");
  exit (0);
}

# process file
if ($fileExt eq '.elx')
{
  ($esdFile, $ecfFile) = elexToScannerDef ($file);
} elsif ($fileExt eq '.esd')
{
  $esdFile = $file;
  $ecfFile = "$fileBase.ecf";
} else
{
  error ("unknown file type $file");
}

if ($opt_c)
{
  if ($esdFile ne $file)
  {
    copyOutfiles ($fileBase, $esdFile, $ecfFile);
  }
} elsif ($opt_d)
{
  debugScannerDef ($esdFile);
} else
{
  @outFiles = scannerDefToCode ($esdFile, $ecfFile, $fileBase);
  copyOutfiles ($fileBase, @outFiles);
}

doCleanup ();

exit (0);