#!/usr/bin/perl
##############################################################
# Converter for Parser for extended HTML code v0.1
# written in 1998/99 by Cyrille Artho, published under the GPL

if ($^O =~ /windows/) { $slash = "\\" }
elsif ($^O =~ /mac/) { $slash = ":" }
else { $slash = "/" }

$dir = '/usr/local/htmlplain';         # directory where HTML PLAIN is installed

if (-e ".".$slash."config.pl") {
  require ".".$slash."config.pl";
  # prefer local config file
} else {
  require "$ENV{HOME}".$slash.".htmlplain".$slash."config.pl";
}

require "$dir".$slash."getargs.pl";
require "$dir".$slash."parsing.pl";
require "$dir".$slash."output.pl";
require "$dir".$slash."storage.pl";
require "$dir".$slash."template.pl";
require "$dir".$slash."variables.pl";
require "$dir".$slash."ldfiletable.pl";
require "$dir".$slash."buffer.pl";
require "$dir".$slash."macros.pl";
use File::Basename;

# fix paths, if needed
$root .= $slash; $outputPath .= $slash;
$root =~ s!$slash{2}$!$slash!;         # only one slash at the end
$outputPath =~ s!$slash{2}$!$slash!;   # only one slash at the end

# variables

$entities = { };                       # create reference to anonymous hash
$tags = { };
$vars = { };
$files = { };
$rev_files = { };                      # reversed filetable
$HTMLfiles = [ ];                      # new anonymous array

&parseVariables($variableFile, $vars);
&parseTemplate($templateFile, $entities, $tags);
&parseFileTable($fileTable, $files, $HTMLfiles);

my @lines;                             # input buffer

# reverse variable, tag, entity and file table
%$entities = reverse %$entities;
$ent_search = getPattern($entities);
%$tags = reverse %$tags;
$tag_search = getPattern($tags);
%$vars = reverse %$vars;
$var_search = getPattern($vars);

foreach my $this (@$HTMLfiles) {
  &processFile($this);
}

# end of main

sub processFile {                      # main loop for each file
  my $this = shift @_;
  my @fileInfo = &loadInfo($files, $this);
  $fileName = shift @fileInfo;
  my $outputFile = &uploadName($fileName);
  my $this_size = shift @fileInfo;
  my $level = shift @fileInfo;
  my $file_search;

  print "Processing $fileName...\n" if $verbose;

  my $flag;

  foreach (keys %$files) {
    if ($_) {
      my @info = loadInfo($files, $_);
      my $path = adjustPath($fileName, $info[0]);
      store($rev_files, $path, $_);
      $file_search .= $path."|";
      $flag = 1;
    }
  }
  if ($file_search) {
    chop $file_search;
    $file_search = "($file_search)";
  } else {
    $file_search - "$^";
  }

  &store($vars, $fileName, "SELF");
  &store($vars, $this, "THIS");

  $line = 0;                           # global line counter

  &clearBuffer;

  unless (open(FILE, $fileName)) {
    &error ("Could not open file $filename: $!\n");
  }

  @lines = <FILE>;                     # read file
  close FILE;

  if ($lines[0] =~ /<!--\s*skip\s*-->/io) {
    &printToBuffer(@lines);
  } else {
    foreach (@lines) {                 # read next line from buffer
      next if /^$/;                    # ignore empty lines
#      s/$tag_search/load($tags, $1)/egio;
      s/$ent_search/"&".load($entities, $1).";"/ego;
      s/$var_search/'"'.load($vars, $1).'"'/ego;
      s/$file_search/load($rev_files, $1)/eg;
      printToBuffer($_);
    }
  }
  &printBufferToFile($outputFile);
}

sub getPattern {
  my $hash_ref = shift @_;
  my $out = "";
  foreach (keys %$hash_ref) {
    if ($_) {
      $out .= $_."|";
    }
  }
  chop $out;
  if ($out) {
    return ("($out)");
  } else {
    return "$^";                       # matches nothing
  }
}
