#!/usr/bin/perl

# papyrus - a perl script to parse REED records & chunk them into a 
database
# some additional translation of typesetting codes into xhtml is done

use Date::Calc;

open LOGFILE,  ">logfile";
open TESTFILE, ">testfile";
open WTF,      ">wtffile";

# DBI initializations to point us at the correct datasource
$driver   = "mysql";
$database = "reed";
$hostname = "localhost";
$dbuser   = "reed";
$dbpwd    = "";            # enter password here

use DBI;

$dsn =
  "DBI:$driver:database=$database;host=$hostname";
$dbh = DBI->connect( $dsn, $dbuser, $dbpwd );

# the doccodes query
$dch = $dbh->prepare(
"select description, repository, location from doccodes where code like ? 
group by code"
);

# some volume initialization
# $id, $paranum, $volume, $volnum, $editor, $text, $rawtext);
$volume = "Inns of Court";
$volnum = 1;
$editor = "Alan H. Nelson";

# where are the footnotes?  make a quick array of the files containing 
them
#@fnfiles = ("IOCFootnotes1(start-1570).txt", 
"IOCFootnotes2(1570-1600).txt",  "IOCFootnotes3(1600-end).txt");
@fnfiles = (
"/stmary/shared/epub/reed/workspace/test/junedata/IOCFN.txt"
);

# set this to turn off/on footnotes handling
$footnotesok = 1;

# start these off blank
$rawtext = $text = "";

# make the reed documents table
$mkreed2 = "CREATE TABLE  reed2 (
  id int(8) NOT NULL auto_increment,
  paranum int(11) NOT NULL default 0,
  text longtext,
  rawtext longtext,
  docdate varchar(255) NOT NULL ,
  description varchar(255) NOT NULL,
  repository varchar(255) NOT NULL, 
  foliation varchar(255) NOT NULL, 
  edsubhead longtext,
  sourcetype varchar(255) NOT NULL, 
  volume varchar(255) NOT NULL ,
  volnum tinyint(4) NOT NULL default 0,
  editor varchar(255) NOT NULL ,
  doctype varchar(255) NOT NULL ,
  section varchar(255) NOT NULL ,
  docname varchar(255) NOT NULL ,
  docpage varchar(255) NOT NULL ,
  PRIMARY KEY  (id)
) TYPE=MyISAM;";

## make the footnotes table

$mkfn = "create table footnotes (
id int not null,
fnum varchar(5),
fnote longtext,
rawtext longtext,
primary key (id),
key (fnum)
) TYPE=MyISAM;";

# make the doccodes table; we don't usually do this,
# since it should remain static, more or less.  For
# the record.
$mkdc = "DROP TABLE IF EXISTS `reed`.`doccodes`;
CREATE TABLE  `reed`.`doccodes` (
  `code` varchar(8) NOT NULL default '',
  `description` varchar(255) NOT NULL default '',
  `repository` varchar(255) NOT NULL default '',
  `loccode` varchar(12) NOT NULL default '',
  `location` varchar(45) NOT NULL default '',
  `sortorder` varchar(45) NOT NULL default '',
  `id` int(10) unsigned NOT NULL auto_increment,
  PRIMARY KEY  (`id`,`sortorder`,`code`),
  KEY `loccode` (`loccode`)
) TYPE=MyISAM;";

# note that this clear-out is redundant, since we DROP TABLE IF EXISTS 
above...
# clear out the past version of the reed table (and notes tables here too)
# & start fresh
$dbh->do("drop table reed2;");
$dbh->do("drop table footnotes;");

$dbh->do($mkreed2);
$dbh->do($mkfn);

# xlation hash

# 10 Mar 09
# some/all of the begin & end pairs should be removed from the hash, and
# treated as grouping replacements.

# the hash xltn should be part of a larger translation subroutine, which 
handles
# both the elements & the structural markup

# XML TEI-Lite xlation hash
%xmlxltn = (
    '\.\.\.', '…',              # ELLIPSIS
    '{',      '<emph rend="italic">', # italics ON
    '}', '</emph>',    # italics OFF

#'--', '&#8211;',	# EN DASH  -- do this afterwards, though -- 
comments complicate things
    '@a\\', '<add place="above">&#8968;'
    , # LEFT CEILING beginning of interlineation above the line
    '@a \\', '&#8969;</add>'
    , # RIGHT CEILING end of interlineation above the line
    '@ ae', '&#230;',    # LATIN SMALL LETTER AE
    '@ AE', '&#198;',    # LATIN CAPITAL LETTER AE
    '@b\\', '<add place="below">&#8970;'
    , # LEFT FLOOR beginning of interlineation below the line ()
    '@b \\', '&#8971;</add>'
    , # RIGHT FLOOR end of interlineation below the line ()
    '@C', '&#8450;'
    , # DOUBLE-STRUCK CAPITAL C (that's not right...) code for a capitulum 
()
    '@d', '&#240;',    # code for an eth ()
    '@e\\',  '<hi rend="bold">', # begin boldface
    '@e \\', '</hi>',            # return to roman
    '@g\\',
    '<foreign lang="Greek">',    # begin greek
    '@g \\', '</foreign>',       # return to roman

#'@i\\' => '&#176;',	# interpolation "bubble", naively using degree 
character
    '@i' => '&#176;'
    , # interpolation "bubble", naively using degree character
    '@j\\', '<hi rend="bold"><hi rend="italic">'
    ,    # begin bold italics
    '@j \\', '</hi></hi>',    # return to roman
    '@k\\',
    '<hi rend="smallcaps">',    # begin small caps
    '@k \\', '</hi>',           # return to roman
    '@m\\',
    '<hi align="center">',   # begins centred text
    '@m \\', '</hi>',        # ends centred text
    '@n',    '&#331;'
    , # LATIN SMALL LETTER ENG Welsh .ng. (looks like combined .nj.) ()
    '@N', '&#330;'
    , # LATIN CAPITAL LETTER ENG Welsh .NG. (looks like combined .NJ.) ()
    '@oe', '&#339;'
    , #  LATIN SMALL LIGATURE OE oe diphthong in ligature ()
    '@OE', '&#338;'
    , # LATIN CAPITAL LIGATURE OE diphthong in ligature ()
    '@P',
    '&#182;',  # PILCROW SIGN paragraphus sign (¶)
    '@q\\',
    '<hi rend="italic"><hi rend="smallcaps">'
    ,          # begin italic small caps
    '@q \\', '</hi></hi>'
    , # return to roman N.B. everything within the @q pair must be typed 
in upper case characters or the conversion won’t work
    '@s\\', '<hi rend="superscript">'
    ,    # begins superscription
    '@s \\', '</hi>',    # ends superscription
    '@th',   '&#254;'
    , # LATIN SMALL LETTER THORN code for a thorn ()
    '@TH', '&#222;'
    , # LATIN CAPITAL LETTER THORN code for capital thorn ()
    '@v', '&#1EFD;'
    , # LATIN SMALL LETTER MIDDLE-WELSH V; CAP=1EFC Welsh .special v. -- 
proposed UCS entity; no codepoint yet; MUFI entitiy 2.0a 1EFC, 1EFD
    '@y', '&#447;',    # LATIN LETTER WYNN wynn ()
    '@z', '&#541;'
    ,   # LATIN SMALL LETTER YOGH code for yogh ()
    '@Z', '&#540;'
    , # LATIN CAPITAL LETTER YOGH code for capital yogh ()
    '@!', '&#33;'
    ,    # EXCLAMATION MARK exclamation point (!)
    '\^', '&#8257;'
    , # CARET INSERTION POINT caret symbol preceding interlineation
    '@\$', '&#163;',   # POUND SIGN pound sign (£)
    '@;',  '&#8271;'
    ,   # REVERSED SEMICOLON inverted semicolon ()

#'@\[', '<-- FLUSHRIGHT -->',	# ALIGNMENT info -- tab (used in accounts 
before flush-right sum)
    '@\*', '&#183;'
    , # MIDDLE DOT raised period, like a semi-colon without the comma part
    '@\%',
    '&#167;',    # SECTION SIGN section symbol ()
    '@u', '<-- HALFPICASPACE -->&nbsp;'
    , # half-pica space	# probably don't need to have this, since it's 
structural
    '@p', '<-- PICASPACE -->&nbsp;',  # pica space

#'\!', '<lb>',	# hard carriage return on the typesetter
    '@\?c',
    '&#231;',  # LATIN SMALL LETTER C WITH CEDILLA
    '@"',
    '&#241;',  # LATIN SMALL LETTER N WITH CEDILLA
    '@\^a',
    '&#226;' # LATIN SMALL LETTER A WITH CIRCUMFLEX

);

# end of xmlxltn hash

#####################

#begin footnotes
if ($footnotesok) {

# note:  @f\#\ and @i\ are fiddled in the main text; I don't think they're 
used in the footnotes

    foreach $fnfile (@fnfiles) {
        open( FOOTNOTES, "< $fnfile" )
          or die
          "Couldn't open that; sorry: $!\n";
        print "Opening $fnfile\n";

        while (<FOOTNOTES>) {
            chomp;
            next if /^--/;
            $fnid++;
            $fnraw = $_;

            # the easy translations
            foreach $string ( keys %xmlxltn ) {

  # turns out we do want doublequoting of the keys
                $qqfindstring = qq{$string};

# and we want to escape trailing slashes in the keys
                $qqfindstring =~ s/\\$/\\\\/;

# replace all occurrences of the quoted, escaped string with its
# value in the xmlxltn hash
s/$qqfindstring/$xmlxltn{$string}/gs;
            }

          # now, let's split it into the fields...
            ( $junk, $fnum, $fnote ) =
              split( /\\/, $_, 3 );
            $fnote =~ s/^  *//;

     #print "RAW $fnum: $fnraw\nNOTE: $fnote\n\n";

# insert into the footnotes table... 
            $dbh->do(
"INSERT INTO footnotes (id, fnum, fnote, rawtext)
         VALUES (?, ?, ?, ?)",
                undef, $fnid, $fnum, $fnote,
                $fnraw
            );
        }
    }
}

#end of footnotes

###################

# reset the record delimiter for the records files
#$/ = "\x21\x0d\x0a\x21\x0d\x0a";

# \n\r!\n\r
$/ = "\x0d\x0a\x21\x0d\x0a";

# begin records
# begin while loop
INPUT: while ( $inline = <> ) {

    # continuation...


    # let's render the footnotes harmless for now
    while (
        $inline =~ s/\@f\\([^\\]*)\\/\@f<$1>/g )
    {

        #print "FOOTNOTES! $1\n";
    }

    # similarly, interpolation bubbles
    while ( $inline =~ s/\@i\\/\@i/g ) {
    }

# if slashbang happens on a line other than @r or @m, get the next line, 
too
    if ( $inline =~
/(?<!\@[rmi] )\x5c\x21\x0d\x0a\x21\x0d\x0a$/
      )
    {
        $continued++;
        print "YEEHA $continued: $inline\n";
        $inline .= <>;
        print "YEEHA2 $continued: $inline\n";
        redo INPUT;
    }

    $inline =~ s/\x0d//gs;

    if ( $inline =~ /\@w.*\@w/ ) {
        $chimera = "CHIMERA: Multiple headers\n";
    }
    else { $chimera = ""; }

    print TESTFILE
      "$i: $chimera<$inline>\nENDOFRECORD\n\n";

# check to see whether there's an @h in this record; if so, initialize the 
record;
# handle the previous record; and carry on...

    # changed to @w:  all records have it
    #  if ($inline =~ /\@[w]/) {
    print LOGFILE "Hey, it's a new record!\n";
    print LOGFILE "START:$inline:END:\n";
    if ($text) {
        &putout;
    }    # whatever the output routine is..

    #     }

    # carry on with processing this chunk
    $i++
      ; # count the chunks... each chunk is probably (?) a paragraph
    $paranum =
      $i;  # we count each paragraph, just in case

    $rawtext .= $inline;
    print LOGFILE
      "Chunk $i / $continued\n<<\n$inline\n>>\n";

# accents etc. -- combining elements -- should get a complete list from 
REED
# in the meantime, compile a hash of unique accents, and then put them out 
at
# the end of the run -- note which ones aren't xlated...
    if ( $inline =~ /\@([.^,:"\?#].)/g ) {
        $unxlt{$1} =
          "Another untranslated thingy";
        print "Hey! A match: $1\n";
        print LOGFILE "UNXLT: $1\n";
    }

# we should translate the open/close pairs first, then the bangslashes,
# if there are any left at that point
    $inline =~ s/\\*!\n$/<lb>\n/gs;

    # the easy translations
    foreach $string ( keys %xmlxltn ) {

# some fiddling here to see what the correct quoting mechanism is

    #print LOGFILE "$string: $xmlxltn{$string}\n";

  # turns out we do want doublequoting of the keys
        $qqfindstring = qq{$string};

# and we want to escape trailing slashes in the keys
        $qqfindstring =~ s/\\$/\\\\/;

# replace all occurrences of the quoted, escaped string with its
# value in the xmlxltn hash
        $inline =~
          s/$qqfindstring/$xmlxltn{$string}/gs;
    }

    # fix those html comments
    $inline =~ s/<--/<!--/g;

    # marginales, left & right
    # this way does them as notes.
    $inline =~
s/\@l\\(.*?)\@l \\/<note type="marginale left" place="left">$1<\/note>/g;
    $inline =~
s/\@r\\(.*?)\@r \\/<note type="marginale right" 
place="right">$1<\/note>/g;

# Technically a misuse of the tagging
    if ( $inline =~
s/(<note type="marginale left" place="left"><hi 
rend="smallcaps">)(ac*)(<\/hi><\/note>)/$1<collection>$2<\/collection>$3/
      )
    {
        $antiquarian = $1;
    }

# note that the -- in comments would get translated by xmlxltn if done 
first...

# catch the various notes -- later, we'll make them active links
    $inline =~
s/\@c\\([0-9A-Za-z]+)\\/<note id="CN.$1" type="collation" 
place="apparatus" n="$1"><SUP>$1<\/SUP><\/note>/g
      ;    # collation note numbers
    $inline =~
s/\@E\\([0-9A-Za-z]+)\\/<note id="EN.$1" type="endnote" place="end" 
n="$1"><SUP>*<\/SUP><\/note>/g
      ;    # endnote numbers

# footnotes were translated from @f\124\ (for example) to @f<124> up above
    $inline =~
s/\@f<([^>]+)>/<note id="FN.$1" type="footnote" place="foot" 
n="$1"><SUP>$1<\/SUP><\/note>/g
      ;    # footnote numbers

    # the head of the record

# wrap the actual quoted document text in <msItem><msContents>...

  # why put <p> at end?
    while ( $inline =~
s/\@h\\(.*?)!(.*?)!(.*?)\n/<head type="heading"><p><hi 
rend="bold"><origDate>$2<\/origDate><\/hi><lb>\n<hi rend="italic">$1<\/hi> 
$3 <lb><\/p><\/head>\n/gs
      )
    {
        $loccode = $1;
        $docdate = $2;
        $code    = $3;
    }

    $code =~ s/\x0a//;
    $code =~ s/\\!//;

#######################

    #BEGINREPOSITORY

# let's get the repository & description; default to codes if there are no 
values
# if we create full xml at ingestion, we would parse the shelf-mark, 
short-author
# and shorttitles here, and tag them as <idno><author><title>...

    $dch->execute($code);

    ( $description, $repository, $location ) =
      $dch->fetchrow_array;
    print "YOWZA: Made it\n";

    $description ||= $code;
    $repository  ||= $loccode;
    $location    ||= "";
    print
"YOWZA: $description $repository $location\n";

# is it a book or a manuscript? check by italics

    if ( $repository ne $loccode ) {
        if ( $repository =~ /rend="emph"/ ) {
            $docsrctype = "printed";
        }
        else { $docsrctype = "manuscript"; }
    }
    else { $docsrctype = ""; }

    print
      "YOWZA: Made it here.\nREPO: $repository\n";

    if ( $repository =~ /(.*?)(: *)(.*)/ ) {
        if ( $docsrctype eq "manuscript" ) {
            $shortrepository = $1;  # <repository>
            $shelfmark       = $3;  # <idno>
            print
"YEEHAA:  $shortrepository | $shelfmark\n";
        }
        elsif ( $docscrtype eq "printed" ) {
            $author = $1;           # <author>
            $title  = $3;           # <title>
            print
              "YEEHAA PRINT:  $author | $title\n";
        }
        else {
            $shortrepository = $shelfmark =
              $author = $title = "";
        }
    }

    print "YOWZA: Made it here 2\n";

# in future versions, this really needs to happen in the doccodes table, I 
think.  

# default to avoid null errors on INSERT... hmmm...
    $docdate     ||= "";
    $description ||= "";
    $repository  ||= "";

    # subhead(s)
    $foliation = "";
    $edsubhead = "";

    while ( $inline =~
s/\@w\\(.*?)( *<emph rend="italic">.*? *)*\\!\n/<p><head 
type="subhead"><locus>$1<\/locus>$2<\/head><\/p>\n/gs
      )
    {
        ;
        $foliation .= $1;
        $edsubhead = $2;
    }
    $foliation ||= "";

    print "FOLIATION: <<$foliation>>\n";
    print "EDSUBHEAD: <<$edsubhead>>\n";
    print LOGFILE "EDSUBHEAD: <<$edsubhead>>\n"
      if $edsubhead;
    print LOGFILE "FOLIATION: <<$foliation>>\n"
      if $foliation;

    #ENDREPOSITORY

###################

    # origDate handling routine
    # we want to tag exact years @when, @from, @to

# 1402, 1402-03, <emph rend="italic">c</emph> 1618-19

    # initialize blank?

    $circa = $from = $to = $when = $dateatts = "";

# this currently depends on <origDate> being inserted already.
    while ( $inline =~
/<origDate>(<emph rend="italic">c<\/emph> 
)*(1*[0-9][0-9][0-9])(--*1*[0-9]*[0-9]*[0-9])*<\/origDate>/
      )
    {

        #print "GOTTIT! $1 $2 $3 \n";
        $circa = $1;
        $from  = $2;
        $to    = $3;

        print LOGFILE
          "CIRCA: $circa FROM: $from TO: $to\n";

        $to =~ s/^--*//;

        unless ($to) {
            $when = $from;
            $from = "";
        }
        else {
            $to = daterange( $from, $to );
        }

        if ($when) {
            $dateatts = " when=\"$when\"";
        }
        elsif ($from) {
            $dateatts .= " from=\"$from\"";
            $dateatts .= " to=\"$to\"";
        }
        if ($circa) {
            $dateatts .= " precision=\"circa\"";
        }
        $inline =~
          s/<origDate>/<origDate $dateatts>/;
    }

# header line
    $msdesc = "<msDesc>\n<msIdentifier>\n";

    $msdesc .=
      "<origPlace>$location</origPlace>\n"
      if $location;

    $msdesc .= "<idno>$shelfmark</idno>\n"
      if $shelfmark;

    $msdesc .= "</msIdentifier>\n</msDesc>\n";

    # end of the msIdentifier header

    $inline = $msdesc . $inline
      unless ( $inline =~ /<msDesc/ );

    print WTF "MSDESC $i: <<$inline>>\n";

    if ( $inline =~ /\@\[|<t/ ) {

        # tabular data.
        # catch the @[ flushrights...
        while ( $inline =~
s/^(.*)\@\[(.*)$/<cell>$1<\/cell><cell rend=\"right\">$2<\/cell>/gm
          )
        {
            print TESTFILE
"TABLEY: <cell>$1</cell><cell>$2</cell><\/tr>\n";
        }

        # catch the <t#>s...
        while ( $inline =~
s/<t([0-9])>(.*)(:!<t)*/<cell \@cols=$1>$2<\/cell>/gm
          )
        {
            print TESTFILE
"TABBY: <cell \@cols=$1>$2<\/cell>\n";
        }

# sometimes the <t#> isn't done at the beginning of the line... 
        while ( $inline =~
s/^((?!<cell).+?)<cell/<cell>$1<\/cell><cell/gm
          )
        {
            print TESTFILE "HEY: $1\n";
            print TESTFILE
              "TABSTART: <cell>$1<\/cell>\n";
            reset;
        }

        # now add the row wrappers
        while ( $inline =~
            s/^(<cell.*cell>)$/<row>$1<\/row>/gm )
        {
            print TESTFILE
              "TABROW: <row>$1<\/row>\n";
        }

# @m at the beginning of a table means it should be the header row
#if ($inline =~ /^(<hi align=\"center\".*<\/hi>\n)(?=<row)/) {
#   print TESTFILE "TABBYHEAD: $1\n";
#   }
        if ( $inline =~ /align=\"center\"/ ) {
            print TESTFILE "TABSAMPLE: $inline\n";
        }
        while ( $inline =~
s/^(<hi align.*?)\n(?=<row)/<row><head>$1<\/head><\/row>\n/gm
          )
        {
            print TESTFILE
              "TABHEAD: <head>$1<\/head>\n";
        }

       # now, wrap the <row> lines with table tags
       # <table> goes on first <row> lines
        while ( $inline =~
            s/(?<!row>\n)^(<row.*)$/<table>$1/gm )
        {
            print TESTFILE
              "TABSAMPLE1: $inline\n";
            print TESTFILE "TABSTART: $1\n";
            print TESTFILE
              "TABSAMPLE2: $inline\n";
        }

        # </table> goes on last <row> lines
        while ( $inline =~
s/^(.*<\/row>)$(?!\n<row>)$/$1<\/table>/gm
          )
        {
            print TESTFILE "TABEND: $1\n";
        }

    }

    # end of the table handling IF

  # scratch notes on tabular data
  # http://www.w3.org/TR/WCAG10-HTML-TECHS/#tables

# how to gather up the tabular stuff: t1, t2, t3, @[...
# <t1> isn't always used first... the # seems to be used as a sort of 
thumbrule guideline,
# rather than any logical tabular markup.  @C & MSBRACE are quite often 
used without separation.
# @[ seems to appear only once per line, ever, mercifully. @m is used to 
center headings,
# but it's probably untrustworthy.


# get footnotes, and update the footnote table
# now loop through the record looking for notes, and jot them
# down in a notes table, so we know what notes there are...
    while (
/<!-- (COLLATIONNOTE|ENDNOTE|FOOTNOTE) ([0-9]+) -->/g
      )
    {
        $notetype = $1;
        $notenum  = $2;

# insert into the footnotes table... this is what we do for Frye...
        $dbh->do(
"INSERT INTO footnotes (ref, notenumber, footnotenumber, chapter)
          VALUES (?, ?, ?, ?)",
            undef, $ref, $para, $footnotenumber,
            $notebook
        );
    }

# Not in IOC; used in Wales, though, I think
#'@x\...@x \' -> '',	
# a sort of sub-sub-heading delimits the line containing names of court 
personnel for ecclesiastical court cases

# sometimes there're comments, descriptions, notes to Gord in the files: 
[[ like this ]]
# and sometimes there are no brackets delimiting them... manual work.

    # let's lop off that trailing <br>\n<br>\n
    $inline =~ s/<br>\n\n*$//g;

    $text .= $inline;
    $text .= "\n";
}    # end of the while loop

# final putout & some logging
&putout if $text;

print LOGFILE "\nTOTAL CHUNKS: $i / $continued\n";

print LOGFILE "\nUNTRANSLATED ACCENTS:\n";

foreach $accent ( keys %unxlt ) {
    print LOGFILE "$accent\n";
}

# daterange procedure

sub daterange ($$) {

    my ( $start, $end ) = @_;

    @dateout = split //, $start;
    @outend  = split //, $end;

    $offset = 0 - scalar(@outend);

    splice(
        @dateout,        $offset,
        scalar(@outend), @outend
    );

    $outdate = join '', @dateout;
    return $outdate;
}

# the output/insertion procedure
sub putout () {

  # wrap the appropriate markup around the critter
    $htmlheader = "<html>
<head>
<title>REED</title>
<body>
";

    $htmltail = "
</body>
</html>";

    $xmlheader = "<text>
<body>
";

    $xmltail = "
</body>
</text>";

    # let's not top & tail for now
    #$text = "$xmlheader$text$xmltail";

    $dbh->do(
"INSERT INTO reed2 (id, paranum, text, rawtext, volume, volnum, editor, 
description, repository, docdate, foliation, edsubhead, sourcetype)
             VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
        undef, $id, $paranum, $text, $rawtext,
        $volume, $volnum, $editor, $description,
        $repository, $docdate, $foliation,
        $edsubhead, $docsrctype
    );

#print LOGFILE "WTF?\n\nX: $id\nX: $paranum\nX: $text\nX: $rawtext\nX: 
$volume\nX: $volnum\nX: $editor\nX: $description\nX: $repository\nX: 
$docdate\n\n";
    print LOGFILE
"WTF?\nDES: $description\nREPO: $repository\n\n";

    # now, clear things out for the next record
    $rawtext       = $text    = $repository =
      $description = $docdate = "";
    print LOGFILE
      "Processed $i\n<<\n$inline\n>>\n";

}

# copyright 2009 Records of Early English Drama