path: root/english/template/debian/recent_list.wml

#use wml::debian::ctime
#use wml::debian::common_tags
#use wml::debian::legal_tags
#use wml::debian::openrecode

<define-tag noitemsforthisyear whitespace=delete>
  <gettext>No items for this year.</gettext>
</define-tag>

<define-tag proposed whitespace=delete>
  <gettext>proposed</gettext>
</define-tag>

<define-tag indiscussion whitespace=delete>
  <gettext>in discussion</gettext>
</define-tag>

<define-tag votingopen whitespace=delete>
  <gettext>voting open</gettext>
</define-tag>

<define-tag finished whitespace=delete>
  <gettext>finished</gettext>
</define-tag>
<define-tag withdrawn whitespace=delete>
  <gettext>withdrawn</gettext>
</define-tag>

<define-tag future_events whitespace=delete>
  <gettext>Future events</gettext>
</define-tag>
<define-tag past_events whitespace=delete>
  <gettext>Past events</gettext>
</define-tag>

<define-tag new_revision whitespace="delete">
    <gettext>(new revision)</gettext>
</define-tag>

<perl>

# get_recent_list( $year, $number, $eng_dir, $format, $match)
#
# get_recent_list grabs the date and title of the last $number special
# files from directory $year.
# The special files can be news, events, security
# advisories and vote summaries.
#
# The format parameter specifies the type of output: numbered, definition
# and bulleted list, a table, or a RDF file (rdf, rdflong, or rfsseq).  
# RDF output is currently only supported for DSAs.
#
# The match parameter is a regexp used to determine if the file is special,
# i.e. that it should be parsed.
#
# When you specify 'bydate' in the format string (you can mix it with
# all the other strings allowed there), the behavior is slightly
# changed: You can specify instead of a year a time, since when
# items should be shown. The format of this time specification
# is \d+(d|w|m|y) for \d+ days/weeks/months/years. $number is then
# only the minimum number of shown items.
# This also enables parsing the report_date tag of security advisories
# as a comma delimited list, so one advisory can have different
# dates for its different revisions.
#
# The interface of this function has several flaws. Some tips:
# As first parameter you must specify the relative path from the site
# on which the list should occour to the directory, that contains
# the $year directories. After the last slash can either follow a year
# or a time specification for bydate (see above).
# As third parameter you must specify the path to the english directory
# of the file you are in.
#
# example usage:
# 1) /index.wml
# get_recent_list( 'security/1m', 10, '$(ENGLISHDIR)', 'bydate', '(2000\d+\w+|dsa-\d+)' )
# 2) News/index.wml
# get_recent_list ('$(CUR_YEAR)', '0', '$(ENGLISHDIR)/News', '', '\d+\w*')
# 3) News/2002/index.wml
# get_recent_list ('.', '0', '$(ENGLISHDIR)/News/2002', '', '\d+\w*')

use Encode;

my ($listhead, $listfoot, $elemhead, $elemdate, $elemfoot, $elememptyfoot, $elemrealfoot);
my $is_events = 0;
my $is_by_date = 0;

sub get_recent_list {
    #clear up
    $is_events = 0;
    $is_by_date = 0;

    my ($time, $minnum, $eng_dir, $format, $match) = @_;
    # djpig: this is a hack for backward compatibility
    # djpig: I would prefer a new argument $rel_path
    # djpig: additionally to $eng_dir
    my $rel_path = ($time =~ s|^(?:\./)?([[:alpha:]]+)/?||) ? $1 : '';
    $rel_path .= '/' unless $rel_path eq '';
    #warn "$rel_path\n";
    my $open_by_path = 0;
    my ($year, $since_year, $since_date);
    # set open_by_path, if no year is specified at all
    unless (($time eq '.')
	    || (($time =~ /\d{4}/) && !$minnum)) {
	$year = $time;
	$since_year = $year;
	$since_date = timegm(0, 0, 0, 1, 0, $year) if $year =~ /\d+/;
	if ($format =~ /bydate/) {
	    $year = $(CUR_YEAR) unless $year =~ /\d{4}/;
	    $since_date = parse_time($time);
	    $since_year = (gmtime($since_date))[5] + 1900;
	    if ($since_year > $year) {
		warn "since_year > year ($since_year > $year)\n";
	    }
	    $is_by_date = 1;
	}
	warn "don't know, what to do: year=$year time=$time\n"
	    unless $since_date =~ /\d+/;
    } else { $open_by_path = 1; }

    #warn scalar gmtime($since_date) . " - " . scalar gmtime() . "\n";

<protect pass="2">
    if ($format =~ order) {
	$listhead = '<ol>';
	$listfoot = '</ol>';
	$elemhead = '<li>';
	$elemfoot = '- ';
	$elememptyfoot = '</li>';
	$elemrealfoot = '</li>';
    } elsif ($format =~ bullet) {
	$listhead = '<ul>';
	$listfoot = '</ul>';
	$elemhead = '<li>';
	$elemfoot = '- ';
	$elememptyfoot = '</li>';
	$elemrealfoot = '</li>';
    } elsif ($format =~ list) {
	$listhead = '<dl>';
	$listhead = '<dl compact>' if $format eq "cdeflist";
	$listfoot = '</dl>';
	$elemhead = '<dt>';
	$elemfoot = '</dt><dd>';
	$elememptyfoot = '</dt>';
	$elemrealfoot = '</dd>';
    } elsif ($format =~ table) {
	$listhead = '<table>';
	$listfoot = '</table>';
	$elemhead = '<tr><td>';
	$elemdate = '</td><td>';
	$elemfoot = '';
	$elememptyfoot = '&nbsp;</td></tr>';
	$elemrealfoot = '</td></tr>';
    } else {
	$listhead = '';
	$listfoot = '';
	$elemhead = '';
	$elemfoot = '- ';
	$elememptyfoot = '';
	$elemrealfoot = '';
    }
</protect>

    my @files;

    # djpig: take $since_year-1, perhaps better define an $oldest_year?
    # djpig: but there should be no more updates to an item after a year
    # djpig: we're saving time so.
    my @years;
    if ( $open_by_path ) { push @years, $time; }
    else { foreach (($since_year-1) .. $year) { push @years, $_; } }
    for my $act_year (@years) {
	opendir DIR, "$eng_dir/$rel_path$act_year"
	    or do {
		# we could not warn here regularly
		# f.e. the actual year can be to new
		#warn "couldn't open dir $eng_dir/$rel_path/$act_year: $!\n";
		next;
	    };
	my @new_files = grep { /^$match.wml$/
				   && -f "$eng_dir/$rel_path$act_year/$_"
				   && ($_="$rel_path$act_year/$_")
			       } readdir(DIR);
	closedir DIR;
	@files = ( @files, @new_files );
    }

    @files = sort {
	($a =~ m,(?:^|/)dsa-(\d+),)[0] <=> ($b =~ m,(?:^|/)dsa-(\d+),)[0] || $a cmp $b
    } @files;

    #warn "files: " . join " ", @files; warn "\n";
    #warn "years: " . join " ", @years; warn "\n";
    #warn "time=$time minnum=$minnum";
    #warn "eng_dir=$eng_dir rel_path=$rel_path format=$format match=$match\n";
    #warn "is_by_date=$is_by_date is_events=$is_events\n";
    #warn "open_by_path=$open_by_path\n";

    my $str = grab_titles( $since_date, $minnum,
			   $eng_dir, $format, $match , @files);

    if ( !$is_events ) { # events already have their head and foot
 	$str = "$listhead$str$listfoot";
    }

    #warn "$str\n";
    return $str;
}

# grab_titles is an auxiliary function to get_recent_list, which actually
# does the real work.
sub grab_titles {
    my ($since_date, $minnum, $eng_dir,
	$format, $match, @files) = @_;
    my ($over, $current, $str);
    my (%str, %count, %over, %current);

    my $count = 0;
    foreach $file (@files) {
	(my $trans_title = $file) =~ s/wml/title/;
	$count++;
	my $str1 = "";
	my @str1 = (); # for bydate
	my $base = $1 if ($file =~ m|^([[:alpha:]./]*(\d{4})?/(?:$match)).wml|);
	#warn "$file -> $base\n";

	# read file in
	my $fh = openrecode($file, $trans_title, "$eng_dir/$file")
	    or die "couldn't open $eng_dir/$file: $!\n";
	my $content;
	<protect pass=2>
	{
	    local $/;
	    $content = Encode::decode_utf8(<$fh>);
	}
	</protect>
	close $fh;

	# decide, if we reading an event file,
	# and if it's a past or current event
	my $event = '';
	if ($WML_SRC_DIRNAME =~ /events/) { # shouldn't waste time if it's not events
	    $is_events = 1;
	    if ($base =~ /-report$/) { next; }
	    <protect pass=2>
		if ($content =~ /^#use wml::debian::past_event$/m) {
		    $event = "past";
		} elsif ($content =~ /^#use wml::debian::event$/m) {
		    $event = "current";
		}
	    </protect>
	 }

	my ($title, $date, $rdate, $rvdate, $hdate, $desc, $status,
	    $where, $moreinfo, $startdate, $enddate, $repfile, $just,
	    $release, $codename, $revision);
	my (@hdate, @rdate, @isodate) = ();
	<protect pass=2>
	if ($content =~ /^<define-tag pagetitle>\s*(.*?)\s*<\/define-tag>/ms) {
	    $title = Encode::encode_utf8(qq/$1/); }      # all
	if ($content =~ /^<define-tag release_date>(.*?)<\/define-tag>/ms) {
	    $date = Encode::encode_utf8(qq/$1/); }       # News, news.XX.rdf
	if ($content =~ /^<p>(.*?)<\/p>/ms) {
            $moreinfo = Encode::encode_utf8(qq/$1/); }   # news.XX.rdf  Should catch the first paragraph
	if ($content =~ /^<define-tag where>(.*?)<\/define-tag>/ms) {
	    $where = Encode::encode_utf8(qq/$1/); }      # events
	if ($content =~ /^<define-tag date>(.*?)<\/define-tag>/ms) {
	    $date = Encode::encode_utf8(qq/$1/); }       # events
	if ($content =~ /^<define-tag description>(.*?)<\/define-tag>/ms) {
	    $desc = Encode::encode_utf8(qq/$1/); }       # security
	if ($content =~ /^<define-tag justification>\s*(.*?)\s*<\/define-tag>/ms) {
	    $just = Encode::encode_utf8(qq/$1/); }      # licenses
	if ($content =~ /^<define-tag moreinfo>(?:(.*?<\/p>)|(.*?)<\/define-tag>)/ms) {
	    $moreinfo = Encode::encode_utf8(qq/$1/); }   # dsa-long.XX.rdf
	if ($content =~ /^<define-tag status>(.*?)<\/define-tag>/ms) {
	    $status = Encode::encode_utf8(qq/$1/); }     # vote
	if ($content =~ /^<define-tag startdate>(.*?)<\/define-tag>/ms) {
	    $startdate = Encode::encode_utf8(qq/$1/); }	# startdate (events)
	if ($content =~ /^<define-tag enddate>(.*?)<\/define-tag>/ms) {
	    $enddate = Encode::encode_utf8($1); }        # enddate (events)
	my ($shortfile) = $file =~ /^(?:.*\/)?(.*)\.wml$/;
	if ($content =~ /<a\s+href="($shortfile-report)"\s*>/ms) {
	    $repfile = Encode::encode_utf8($1); }        # Report (events)
	if ($content =~ /<report\s+href="([^"]*)\s*"\/?>/ms) { #"
            $repfile = Encode::encode_utf8($1); }        # Report (events)
	if ($content =~ /^<define-tag release>(.*?)<\/define-tag>/ms) {
	    $release = Encode::encode_utf8(qq/$1/); }	# News
	if ($content =~ /^<define-tag codename>(.*?)<\/define-tag>/ms) {
	    $codename = Encode::encode_utf8(qq/$1/); }	# News
	if ($content =~ /^<define-tag revision>(.*?)<\/define-tag>/ms) {
	    $revision = Encode::encode_utf8(qq/$1/); }	# News
	</protect>
	$hdate = $date || $startdate;
	#warn "file=$file hdate=$hdate date=$date rdate=$rdate\n";
	if ($startdate && $enddate) { # Convert date range into printable string
	    $date = &daterange($startdate, $enddate);
	}
	if ($title && $date && $where) { # for events/
	    if ($date !~ /^[\d-\s]+$/ ) { # old events dates
		$hdate = "";
	    }
	    my $report = ($repfile)
		? " [<a href=\"$repfile\"><gettext>Report</gettext></a>]"
		: '';
	    $str1 = "$elemhead<tt>[$date]</tt>$elemdate <strong><a href=\"$base\">$title</a></strong>, $elemfoot$where$report<br />$elemrealfoot\n";
	}
	elsif ($desc) { # for security/
	    # read in datafile
	    open DATAFILE, "$eng_dir/$base.data"
		or do {
		    warn "couldn't open $eng_dir/$base.data: $!\n";
		    next;
		};
	    <protect pass=2>
	     foreach my $l (<DATAFILE>) {
		 if ($l =~ /^<define-tag pagetitle>(.*)<\/define-tag>/)
		 { $title = qq/$1/; }
		 elsif ($l =~ /^<define-tag report_date>(.*)<\/define-tag>/)
		 { $rdate = qq/$1/; }
	     }
	    </protect>
	    close DATAFILE;

	    @hdate = split ',', $rdate;
	    $hdate = $hdate[0];
	    $isodate = sprintf("%04d-%02d-%02d", split '-', $hdate[-1]);
	    $rdate = newsdate($hdate);
	    @rdate = map( newsdate($_), @hdate );
	    @isodate = map( sprintf("%04d-%02d-%02d", split '-', $_), @hdate );
	    $title =~ s/(DSA-\d{3,})-\d{1}/$1/; # strip off the revision in the DSA number
	    # we need absolute paths for rdf
	    (my $rdfbase = $base) =~ s/^security\///;
	    if ($format =~ /\brdf\b/) {
		foreach (@isodate)
		{
		    push @str1, "\n"
			."<item rdf:about=\"https://www.debian.org"
			."/security/$rdfbase\">\n"
			."  <title>$title</title>\n"
			."  <link>https://www.debian.org/"
			."security/$rdfbase</link>\n"
			."  <description>\n"
			."    $desc\n"
			."  </description>\n"
			."  <dc:date>$_</dc:date>\n"
			."</item>\n";
                }
		$str1 = $str1[0];
	    } elsif ($format =~ /\brdflong\b/) {
                # $moreinfo is WML/HTML; we need to strip tags here
                <protect pass=2>
                # HTML entities
                $moreinfo =~ s/(&[^#;]+;)/&decodehtmlentity($1)/ge;
                # <email "xxx"> <url "xxx">
                $moreinfo =~ s#<email "?([^>"]+)"?>#<a href="mailto:$1">$1</a>#g;
                $moreinfo =~ s#<url "([^>]+)">#<a href="$1">$1</a>#g;
                # HTML tags
                $moreinfo =~ s/</&lt;/g;
                $moreinfo =~ s/>/&gt;/g;
                $moreinfo =~ s/"/&quot;/g; #"
                # WML continuation
                $moreinfo =~ s/\\\n//g;
                </protect>
		foreach (@isodate)
		{
		    push @str1, "\n"
			."<item rdf:about=\"https://www.debian.org"
			."/security/$rdfbase\">\n"
			."  <title>$title - $desc</title>\n"
			."  <link>https://www.debian.org"
			."/security/$rdfbase</link>\n"
			."  <description>\n"
			."    $moreinfo\n"
			."  </description>\n"
			."  <dc:date>$_</dc:date>\n"
			."</item>\n";
		}
	        $str1 = @str1[0];
	    } elsif ($format =~ /\brdfseq/){
		foreach (@isodate)
		{
<protect pass=2>
		    push @str1, "<rdf:li resource=\"https://www.debian.org"
                        ."/security/$rdfbase\" />\n";
</protect>
		}
		$str1 = $str1[0];
	    } else {
		foreach( @rdate ) {
		    push @str1, "$elemhead<tt>[$_]</tt> "
			."<strong><a href=\"$base\">$title</a></strong> "
			."$elemfoot$desc NEW_REVISION<br />$elemrealfoot\n";
		}
		$str1 = $str1[0];
	    }
	}
        elsif ($just) { # for licenses/
	    # read in datafile
	    open DATAFILE, "$eng_dir/$base.data"
		or do {
		    warn "couldn't open $eng_dir/$base.data: $!\n";
		    next;
		};
	    <protect pass=2>
             my ( $free, $l_name );
	     foreach my $l (<DATAFILE>) {
		 if ($l =~ /^<define-tag pagetitle>(.*)<\/define-tag>/)
		 { $title = qq/$1/; }
		 if ($l =~ /^<define-tag license-name>(.*)<\/define-tag>/)
		 { $l_name = qq/$1/; }
		 elsif ($l =~ /^<define-tag report_date>(.*)<\/define-tag>/)
		 { $rdate = qq/$1/; }
		 elsif ($l =~ /^<define-tag isfree>(.*)<\/define-tag>/)
		 { $free = qq/$1/; }
	     }
	    </protect>
	    close DATAFILE;
            $rdate = newsdate($rdate);
            if ($free eq 'yes') {
                $free = '<dls-result isfree="yes" />';
            } elsif ($free eq 'no') {
                $free = '<dls-result isfree="no" />';
            } elsif ($free eq 'non-dist') {
                $free = '<dls-result isfree="non-dist" />';
            }
            $str1 = "$elemhead<tt>[$rdate]</tt> "
                ."<strong><a href=\"$base\">$title</a></strong>$elemfoot "
                ."$l_name &ndash; $free<br />$elemrealfoot\n";
        }
	elsif ($title && $date && !$is_events) { # for News/ and not events/
            # read in datafile
            open DATAFILE, "$eng_dir/$base.wml"
		or do {
		    warn "couldn't open $eng_dir/$base.wml: $!\n";
		    next;
		};
	    <protect pass=2>
	     foreach my $l (<DATAFILE>) {
		 if ($l =~ /^<define-tag release_date>(.*)<\/define-tag>/)
		 { $rdate = qq/$1/; }
	     }
	    </protect>
	    close DATAFILE;

	    @hdate = split ',', $rdate;
	    $hdate = $hdate[0];
	    $isodate = sprintf("%04d-%02d-%02d", split '-', $hdate[-1]);
	    $rdate = newsdate($hdate);
	    @rdate = map( newsdate($_), @hdate );
	    @isodate = map( sprintf("%04d-%02d-%02d", split '-', $_), @hdate );
	    # we need absolute paths for rdf
	    (my $rdfbase = $base) =~ s/^News\///;
            if ($format =~ /\brdflong\b/) {
                # $moreinfo is WML/HTML; we need to strip tags here
                <protect pass=2>
                # HTML entities
                $moreinfo =~ s/(&[^#;]+;)/&decodehtmlentity($1)/ge;
                # <email "xxx"> <url "xxx">
                $moreinfo =~ s#<email "?([^>"]+)"?>#<a href="mailto:$1">$1</a>#g;
                $moreinfo =~ s#<url "([^>]+)">#<a href="$1">$1</a>#g;
                $moreinfo =~ s#\$\(HOME\)#https://www.debian.org#g;
                $moreinfo =~ s#<release>#$release#g;
                $moreinfo =~ s#<codename>#$codename#g;
                $moreinfo =~ s#<revision>#$revision#g;
                # HTML tags
                $moreinfo =~ s/</&lt;/g;
                $moreinfo =~ s/>/&gt;/g;
                $moreinfo =~ s/"/&quot;/g; #"
                $title =~ s/<\/?q>/&quot;/g;
                $title =~ s/<\/?sup>//g;
                $title =~ s/</&lt;/g;
                $title =~ s/>/&gt;/g;
                $title =~ s/"/&quot;/g; #"
                # WML continuation
                $moreinfo =~ s/\\\n//g;
                </protect>
		foreach (@isodate)
		{
		    push @str1, "\n"
			."<item rdf:about=\"https://www.debian.org"
			."/News/$rdfbase\">\n"
			."  <title>$title</title>\n"
			."  <link>https://www.debian.org"
			."/News/$rdfbase</link>\n"
			."  <description>\n"
			."    $moreinfo\n"
			."  </description>\n"
			."  <dc:date>$_</dc:date>\n"
			."</item>\n";
		}
	        $str1 = @str1[0];
	    } elsif ($format =~ /\brdfseq/){
		foreach (@isodate)
		{
<protect pass=2>
		    push @str1, "<rdf:li resource=\"https://www.debian.org"
                        ."/News/$rdfbase\" />\n";
</protect>
		}
		$str1 = $str1[0];
	        $str1 = @str1[0];
	    } else {
	        $date = newsdate($date);
	        $str1 = "$elemhead<tt>[$date]</tt> "
		  ."<strong><a href=\"$base\">$title</a></strong><br />"
		  ."$elemrealfoot\n";
           }
	}

	elsif ($title && $status) { # for vote/
	    $str1 = "$elemhead<a href=\"$base\">$title</a> &mdash; ";
	    if ( $status eq "P" ) { $str1 .= "<proposed/>"; }
	    elsif ( $status eq "D" ) { $str1 .= "<indiscussion/>"; }
	    elsif ( $status eq "V" ) { $str1 .= "<votingopen/>"; }
	    elsif ( $status eq "F" ) { $str1 .= "<finished/>"; }
	    elsif ( $status eq "W" ) { $str1 .= "<withdrawn/>"; }
	    else { $str1 .= "$status"; }
	    $str1 .= "<br />$elememptyfoot\n";
	}

	if (!$is_by_date || ($hdate eq "")) {
	    $hdate = $count;
	} else {
	    $hdate = iso2stamp( $hdate );
	    @hdate = map(iso2stamp($_), @hdate);
	}
	#warn "$file: hdate=$hdate (".join( ":", @hdate ).")\n";

	if ($event ne "") { # this file was for an event
	    if ( $event eq "past" ) {
		$over{$hdate} .= $str1;
		$count{$hdate}++;
	    }
	    elsif ( $event eq "current" ) {
		$current{$hdate} .= $str1;
		$count{$hdate}++;
	    }
	} else {
	    #warn "$file: no event?" if $is_events;
	    unless ( ($#hdate > 0) && $is_by_date ) {
		($str{$hdate} = $str1 . $str{$hdate}) =~ s/NEW_REVISION//;
		$count{$hdate}++;
	    } else {
		if ( $#hdate != $#str1 ) { warn '$#hdate != $#str1\n'; }
		($str{$hdate[0]} = $str1[0] . $str{$hdate[0]}) =~ s/NEW_REVISION//;
		for (1..$#str1) {
		    ($str{$hdate[$_]} = $str1[$_] . $str{$hdate[$_]})
			=~ s,NEW_REVISION,<new_revision/>,;
		    $count{$hdate[$_]}++;
		}
	    }
	}
    } # for each file

    if ($is_events) {
	$str = "";
	$over = pick_recent( $since_date, $minnum, \%over, \%count);
	$current = pick_recent( $since_date, $minnum, \%current, \%count, "reverse:quietnull" );
	if ($current) {
	    $str = "<h2><future_events/></h2>\n$listhead\n$current\n$listfoot\n";
	}
	if ($over) {
	    $str .= "<h2><past_events/></h2>\n$listhead\n$over\n$listfoot\n";
	}
    } else {
	$str = pick_recent( $since_date, $minnum, \%str, \%count);
    }

return $str;
}

# pick_recent picks the item from an hash and concatenates them to a string.
# Input: $since_date - integer timestamp
#        $minnum - at least this number of items are picked
#                  (if the hash is big enough)
#        %str - hash with timestamps as keys and strings as values
# Output: string with the concatenated values of the picked items
#
# pick_recent sorts the keys of the array newest to oldest and then picks
# the first $minnum one and then until a key is lower then $since_date.
sub pick_recent {
    my ($since_date, $minnum, $str, $str_count, $sort) = @_;
    my $out_str = '';
    my $count = 0;

    my @keys;
    if (defined($sort) && ($sort =~ /reverse/)) {
	@keys = sort { $a <=> $b } keys %$str;
    } else {
	@keys = sort { $b <=> $a } keys %$str;
    }
    #warn "since_date: ".scalar gmtime($since_date)." minnum: $minnum\n";
    foreach (@keys) {
	#warn "date: ".scalar gmtime($_)." ($count >= $minnum) && ($_ < $since_date)\n";
	if ($count >= $minnum) {
	    if( (!$is_by_date && $minnum)
		|| (($is_by_date || !$minnum)
		    && ($_ < $since_date)) ) {
		last;
	    }
	}
	$out_str .= ${$str}{$_};
	$count += ${$str_count}{$_};
	#warn "infinite loop?\n" unless $count % 1000;
    }

    if (($count eq 0) && ($sort !~ /quietnull/)) {
	$out_str = "<noitemsforthisyear/>\n";
	$out_str = $elemhead . $out_str . $elemrealfoot if $is_events;
    }
    #warn "count: $count\n";
    #warn "$out_str\n";

    return $out_str;
}

# parse_time gets as argument a string and returns a unix timestamp
# Input: $time_str - String with the following format
#                    $time_str ::= <integer>(d|w|m|y)
# Output: integer timestamp
#
# parse_time subtracts <integer> days/weeks/months from the actual time and
# returns the corresponding timestamp. Years are handled special: 1y means
# "since January, 1st of actual year", 2y means "since January, 1st of
# last year", etc.
sub parse_time {
    my $time_str = shift;
    my $year = (gmtime())[5] + 1900;
    my $time = time();
    my $res;

    for ($time_str) {
	/\d{4}/ && do {
	    $res = timegm(0,0,0,1,0,$year);
	    last;
	};

	/(\d+)d/ && do {
	    $res = $time - 86400 * $1;
	    last;
	};

	/(\d+)w/ && do {
	    $res = $time - 86400 * 7 * $1;
	    last;
	};

	/(\d+)m/ && do {
	    # All months have 30 days,
	    # all other would be far more complicated
	    $res = $time - 86400 * 30 * $1;
	    last;
	};

	/(\d+)y/ && do {
	    # years are handled special
	    my $ryear = $year - $1 + 1; # the actual year count as a whole one
	    $res = timegm(0,0,0,1,0,$ryear); # 01.01.$ryear 00:00:00
	    last;
	};

    }

    return $res;
}

# iso2stamp converts a date in ISO format (YYYY-MM-DD) to an
# unix timestamp for 23:59:59 on the specified day
# Input: $time - String with the ISO date
# Output: integer timestamp
sub iso2stamp {
    my $time = shift;

    if ($time =~ /undated/) {
	return 0;
    }
    my ($year, $month, $day) = ($time =~ /(\d{4})-(\d{1,2})-(\d{1,2})/);
    unless ($year && $month && $day) { warn "not an ISO date: $time\n"; }

    return timegm( 59, 59, 23, $day, $month-1, $year);
}

# decode_html_entity is used in the RDF outputs to convert the predefined
# HTML/SGML entities to NCRs, as they are not predefined for XML formats.
sub decodehtmlentity {
  my $ent = shift;

  # ISO 8859-1 entities
  @entities = (
    '&nbsp;', '&iexcl;', '&cent;', '&pound;', '&curren;', '&yen;',
    '&brvbar;', '&sect;', '&uml;', '&copy;', '&ordf;', '&laquo;', '&not;',
    '&shy;', '&reg;', '&macr;', '&deg;', '&plusmn;', '&sup2;', '&sup3;',
    '&acute;', '&micro;', '&para;', '&middot;', '&cedil;', '&sup1;',
    '&ordm;', '&raquo;', '&frac14;', '&frac12;', '&frac34;', '&iquest;',
    '&Agrave;', '&Aacute;', '&Acirc;', '&Atilde;', '&Auml;', '&Aring;',
    '&AElig;', '&Ccedil;', '&Egrave;', '&Eacute;', '&Ecirc;', '&Euml;',
    '&Igrave;', '&Iacute;', '&Icirc;', '&Iuml;', '&ETH;', '&Ntilde;',
    '&Ograve;', '&Oacute;', '&Ocirc;', '&Otilde;', '&Ouml;', '&times;',
    '&Oslash;', '&Ugrave;', '&Uacute;', '&Ucirc;', '&Uuml;', '&Yacute;',
    '&THORN;', '&szlig;', '&agrave;', '&aacute;', '&acirc;', '&atilde;',
    '&auml;', '&aring;', '&aelig;', '&ccedil;', '&egrave;', '&eacute;',
    '&ecirc;', '&euml;', '&igrave;', '&iacute;', '&icirc;', '&iuml;',
    '&eth;', '&ntilde;', '&ograve;', '&oacute;', '&ocirc;', '&otilde;',
    '&ouml;', '&divide;', '&oslash;', '&ugrave;', '&uacute;', '&ucirc;',
    '&uuml;', '&yacute;', '&thorn;', '&yuml;'
  );

  for (my $i = 0; $i < $#entities; ++ $i)
  {
    return "&#".($i+160).";" if $entities[$i] eq $ent;
  }

  # Non-ISO 8859-1 entities
  %entities = (
    # Specials
    '&OElig;' => '&#338;',
    '&oelig;' => '&#339;',
    '&Scaron;' => '&#352;',
    '&scaron;' => '&#353;',
    '&Yuml;' => '&#376;',
    '&circ;' => '&#710;',
    '&tilde;' => '&#732;',
    '&ensp;' => '&#8194;',
    '&emsp;' => '&#8195;',
    '&thinsp;' => '&#8201;',
    '&zwnj;' => '&#8204;',
    '&zwj;' => '&#8205;',
    '&lrm;' => '&#8206;',
    '&rlm;' => '&#8207;',
    '&ndash;' => '&#8211;',
    '&mdash;' => '&#8212;',
    '&lsquo;' => '&#8216;',
    '&rsquo;' => '&#8217;',
    '&sbquo;' => '&#8218;',
    '&ldquo;' => '&#8220;',
    '&rdquo;' => '&#8221;',
    '&bdquo;' => '&#8222;',
    '&dagger;' => '&#8224;',
    '&Dagger;' => '&#8225;',
    '&permil;' => '&#8240;',
    '&lsaquo;' => '&#8249;',
    '&rsaquo;' => '&#8250;',
    '&euro;' => '&#8364;',
    # Symbols
    '&fnof;' => '&#402;',
    '&Alpha;' => '&#913;',
    '&Beta;' => '&#914;',
    '&Gamma;' => '&#915;',
    '&Delta;' => '&#916;',
    '&Epsilon;' => '&#917;',
    '&Zeta;' => '&#918;',
    '&Eta;' => '&#919;',
    '&Theta;' => '&#920;',
    '&Iota;' => '&#921;',
    '&Kappa;' => '&#922;',
    '&Lambda;' => '&#923;',
    '&Mu;' => '&#924;',
    '&Nu;' => '&#925;',
    '&Xi;' => '&#926;',
    '&Omicron;' => '&#927;',
    '&Pi;' => '&#928;',
    '&Rho;' => '&#929;',
    '&Sigma;' => '&#931;',
    '&Tau;' => '&#932;',
    '&Upsilon;' => '&#933;',
    '&Phi;' => '&#934;',
    '&Chi;' => '&#935;',
    '&Psi;' => '&#936;',
    '&Omega;' => '&#937;',
    '&alpha;' => '&#945;',
    '&beta;' => '&#946;',
    '&gamma;' => '&#947;',
    '&delta;' => '&#948;',
    '&epsilon;' => '&#949;',
    '&zeta;' => '&#950;',
    '&eta;' => '&#951;',
    '&theta;' => '&#952;',
    '&iota;' => '&#953;',
    '&kappa;' => '&#954;',
    '&lambda;' => '&#955;',
    '&mu;' => '&#956;',
    '&nu;' => '&#957;',
    '&xi;' => '&#958;',
    '&omicron;' => '&#959;',
    '&pi;' => '&#960;',
    '&rho;' => '&#961;',
    '&sigmaf;' => '&#962;',
    '&sigma;' => '&#963;',
    '&tau;' => '&#964;',
    '&upsilon;' => '&#965;',
    '&phi;' => '&#966;',
    '&chi;' => '&#967;',
    '&psi;' => '&#968;',
    '&omega;' => '&#969;',
    '&thetasym;' => '&#977;',
    '&upsih;' => '&#978;',
    '&piv;' => '&#982;',
    '&bull;' => '&#8226;',
    '&hellip;' => '&#8230;',
    '&prime;' => '&#8242;',
    '&Prime;' => '&#8243;',
    '&oline;' => '&#8254;',
    '&frasl;' => '&#8260;',
    '&weierp;' => '&#8472;',
    '&image;' => '&#8465;',
    '&real;' => '&#8476;',
    '&trade;' => '&#8482;',
    '&alefsym;' => '&#8501;',
    '&larr;' => '&#8592;',
    '&uarr;' => '&#8593;',
    '&rarr;' => '&#8594;',
    '&darr;' => '&#8595;',
    '&harr;' => '&#8596;',
    '&crarr;' => '&#8629;',
    '&lArr;' => '&#8656;',
    '&uArr;' => '&#8657;',
    '&rArr;' => '&#8658;',
    '&dArr;' => '&#8659;',
    '&hArr;' => '&#8660;',
    '&forall;' => '&#8704;',
    '&part;' => '&#8706;',
    '&exist;' => '&#8707;',
    '&empty;' => '&#8709;',
    '&nabla;' => '&#8711;',
    '&isin;' => '&#8712;',
    '&notin;' => '&#8713;',
    '&ni;' => '&#8715;',
    '&prod;' => '&#8719;',
    '&sum;' => '&#8721;',
    '&minus;' => '&#8722;',
    '&lowast;' => '&#8727;',
    '&radic;' => '&#8730;',
    '&prop;' => '&#8733;',
    '&infin;' => '&#8734;',
    '&ang;' => '&#8736;',
    '&and;' => '&#8743;',
    '&or;' => '&#8744;',
    '&cap;' => '&#8745;',
    '&cup;' => '&#8746;',
    '&int;' => '&#8747;',
    '&there4;' => '&#8756;',
    '&sim;' => '&#8764;',
    '&cong;' => '&#8773;',
    '&asymp;' => '&#8776;',
    '&ne;' => '&#8800;',
    '&equiv;' => '&#8801;',
    '&le;' => '&#8804;',
    '&ge;' => '&#8805;',
    '&sub;' => '&#8834;',
    '&sup;' => '&#8835;',
    '&nsub;' => '&#8836;',
    '&sube;' => '&#8838;',
    '&supe;' => '&#8839;',
    '&oplus;' => '&#8853;',
    '&otimes;' => '&#8855;',
    '&perp;' => '&#8869;',
    '&sdot;' => '&#8901;',
    '&lceil;' => '&#8968;',
    '&rceil;' => '&#8969;',
    '&lfloor;' => '&#8970;',
    '&rfloor;' => '&#8971;',
    '&lang;' => '&#9001;',
    '&rang;' => '&#9002;',
    '&loz;' => '&#9674;',
    '&spades;' => '&#9824;',
    '&clubs;' => '&#9827;',
    '&hearts;' => '&#9829;',
    '&diams;' => '&#9830;',
  );
  return $entities{$ent} if defined $entities{$ent};
  return '?'; # Say what?
}
</perl>

#
# vim:ts=8:sw=4:
#