diff --git a/Makefile.PL b/Makefile.PL
index 59c5d86..a346b17 100755
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -19,14 +19,17 @@ extra_build:
 		--plugin=orphans --plugin=haiku --plugin=meta
 	./mdwn2man ikiwiki 1 doc/usage.mdwn > ikiwiki.man
 	./mdwn2man ikiwiki-mass-rebuild 8 doc/ikiwiki-mass-rebuild.mdwn > ikiwiki-mass-rebuild.man
+	cd l10n && $(MAKE) install
 		
 extra_clean:
 	rm -rf html doc/.ikiwiki
 	rm -f ikiwiki.man ikiwiki-mass-rebuild.man
+	cd l10n && $(MAKE) distclean
 
 extra_install:
-	install -d $(PREFIX)/share/ikiwiki/templates
-	cp templates/* $(PREFIX)/share/ikiwiki/templates
+	install -d $(PREFIX)/share/ikiwiki/templates/en
+	cp templates/* $(PREFIX)/share/ikiwiki/templates/en
+	cp -a translations/* $(PREFIX)/share/ikiwiki/templates/ || true
 
 	install -d $(PREFIX)/share/ikiwiki/basewiki
 	cp -a basewiki/* $(PREFIX)/share/ikiwiki/basewiki
diff --git a/l10n/Makefile b/l10n/Makefile
new file mode 100644
index 0000000..ee1311b
--- /dev/null
+++ b/l10n/Makefile
@@ -0,0 +1,38 @@
+TMPL_PROCESS = ./tmpl_process3.pl
+
+SOURCE_DIR   = ../templates
+TARGET_DIR   = ../translations
+PO_DIR       = ../po
+POT_FILE     = $(PO_DIR)/templates.pot
+
+LANGUAGES    = $(patsubst $(PO_DIR)/%.po, $(TARGET_DIR)/%, $(wildcard $(PO_DIR)/*.po))
+
+all: install
+
+pot: $(POT_FILE)
+
+update: pot $(wildcard $(PO_DIR)/*.po)
+
+install: $(LANGUAGES)
+
+clean:
+	rm -rf $(PO_DIR)/*~ $(LANGUAGES)
+
+distclean: clean
+	rmdir --ignore-fail-on-non-empty $(TARGET_DIR)
+
+%.pot: $(wildcard $(SOURCE_DIR)/*.tmpl)
+	mkdir -p $(dir $@)
+	rm -f $@
+	$(TMPL_PROCESS) create -s $@ -r -i $(SOURCE_DIR)
+
+%.po: $(wildcard $(SOURCE_DIR)/*.tmpl)
+	$(TMPL_PROCESS) update -s $@ -r -i $(SOURCE_DIR)
+	touch $@ # TMPL_PROCESS doesn't touch file if not needed
+
+$(TARGET_DIR)/%: $(PO_DIR)/%.po
+	mkdir -p $@
+	$(TMPL_PROCESS) install -s $< -o $@ -r -i $(SOURCE_DIR)
+	touch $@ # TMPL_PROCESS doesn't touch dir if not needed
+
+.PHONY: update pot
diff --git a/l10n/TmplToken.pm b/l10n/TmplToken.pm
new file mode 100644
index 0000000..0a54d0b
--- /dev/null
+++ b/l10n/TmplToken.pm
@@ -0,0 +1,157 @@
+package TmplToken;
+
+use strict;
+use TmplTokenType;
+require Exporter;
+
+use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
+
+###############################################################################
+
+=head1 NAME
+
+TmplToken.pm - Object representing a scanner token for .tmpl files
+
+=head1 DESCRIPTION
+
+This is a class representing a token scanned from an HTML::Template .tmpl file.
+
+=cut
+
+###############################################################################
+
+$VERSION = 0.01;
+
+@ISA = qw(Exporter);
+@EXPORT_OK = qw();
+
+###############################################################################
+
+sub new {
+    my $this = shift;
+    my $class = ref($this) || $this;
+    my $self = {};
+    bless $self, $class;
+    ($self->{'_string'}, $self->{'_type'}, $self->{'_lc'}, $self->{'_path'}) = @_;
+    return $self;
+}
+
+sub string {
+    my $this = shift;
+    return $this->{'_string'}
+}
+
+sub type {
+    my $this = shift;
+    return $this->{'_type'}
+}
+
+sub pathname {
+    my $this = shift;
+    return $this->{'_path'}
+}
+
+sub line_number {
+    my $this = shift;
+    return $this->{'_lc'}
+}
+
+sub attributes {
+    my $this = shift;
+    return $this->{'_attr'};
+}
+
+sub set_attributes {
+    my $this = shift;
+    $this->{'_attr'} = ref $_[0] eq 'HASH'? $_[0]: \@_;
+    return $this;
+}
+
+# only meaningful for TEXT_PARAMETRIZED tokens
+sub children {
+    my $this = shift;
+    return $this->{'_kids'};
+}
+
+# only meaningful for TEXT_PARAMETRIZED tokens
+sub set_children {
+    my $this = shift;
+    $this->{'_kids'} = ref $_[0] eq 'ARRAY'? $_[0]: \@_;
+    return $this;
+}
+
+# only meaningful for TEXT_PARAMETRIZED tokens
+# FIXME: DIRECTIVE is not necessarily TMPL_VAR !!
+sub parameters_and_fields {
+    my $this = shift;
+    return map { $_->type == TmplTokenType::DIRECTIVE? $_:
+		($_->type == TmplTokenType::TAG
+			&& $_->string =~ /^<input\b/is)? $_: ()}
+	    @{$this->{'_kids'}};
+}
+
+# only meaningful for TEXT_PARAMETRIZED tokens
+sub anchors {
+    my $this = shift;
+    return map { $_->type == TmplTokenType::TAG && $_->string =~ /^<a\b/is? $_: ()} @{$this->{'_kids'}};
+}
+
+# only meaningful for TEXT_PARAMETRIZED tokens
+sub form {
+    my $this = shift;
+    return $this->{'_form'};
+}
+
+# only meaningful for TEXT_PARAMETRIZED tokens
+sub set_form {
+    my $this = shift;
+    $this->{'_form'} = $_[0];
+    return $this;
+}
+
+sub has_js_data {
+    my $this = shift;
+    return defined $this->{'_js_data'} && ref($this->{'_js_data'}) eq 'ARRAY';
+}
+
+sub js_data {
+    my $this = shift;
+    return $this->{'_js_data'};
+}
+
+sub set_js_data {
+    my $this = shift;
+    $this->{'_js_data'} = $_[0];
+    return $this;
+}
+
+# predefined tests
+
+sub tag_p {
+    my $this = shift;
+    return $this->type == TmplTokenType::TAG;
+}
+
+sub cdata_p {
+    my $this = shift;
+    return $this->type == TmplTokenType::CDATA;
+}
+
+sub text_p {
+    my $this = shift;
+    return $this->type == TmplTokenType::TEXT;
+}
+
+sub text_parametrized_p {
+    my $this = shift;
+    return $this->type == TmplTokenType::TEXT_PARAMETRIZED;
+}
+
+sub directive_p {
+    my $this = shift;
+    return $this->type == TmplTokenType::DIRECTIVE;
+}
+
+###############################################################################
+
+1;
diff --git a/l10n/TmplTokenType.pm b/l10n/TmplTokenType.pm
new file mode 100644
index 0000000..75d4f52
--- /dev/null
+++ b/l10n/TmplTokenType.pm
@@ -0,0 +1,128 @@
+package TmplTokenType;
+
+use strict;
+require Exporter;
+
+use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
+
+###############################################################################
+
+=head1 NAME
+
+TmplTokenType.pm - Types of TmplToken objects
+
+=head1 DESCRIPTION
+
+This is a Java-style "safe enum" singleton class for types of TmplToken objects.
+The predefined constants are
+
+=cut
+
+###############################################################################
+
+$VERSION = 0.01;
+
+@ISA = qw(Exporter);
+@EXPORT_OK = qw(
+    &TEXT
+    &TEXT_PARAMETRIZED
+    &CDATA
+    &TAG
+    &DECL
+    &PI
+    &DIRECTIVE
+    &COMMENT
+    &UNKNOWN
+);
+
+###############################################################################
+
+use vars qw( $_text $_text_parametrized $_cdata
+    $_tag $_decl $_pi $_directive $_comment $_null $_unknown );
+
+BEGIN {
+    my $new = sub {
+	my $this = 'TmplTokenType';#shift;
+	my $class = ref($this) || $this;
+	my $self = {};
+	bless $self, $class;
+	($self->{'id'}, $self->{'name'}, $self->{'desc'}) = @_;
+	return $self;
+    };
+    $_text		= &$new(0, 'TEXT');
+    $_text_parametrized	= &$new(8, 'TEXT-PARAMETRIZED');
+    $_cdata		= &$new(1, 'CDATA');
+    $_tag		= &$new(2, 'TAG');
+    $_decl		= &$new(3, 'DECL');
+    $_pi		= &$new(4, 'PI');
+    $_directive		= &$new(5, 'DIRECTIVE');
+    $_comment		= &$new(6, 'COMMENT');
+    $_unknown		= &$new(7, 'UNKNOWN');
+}
+
+sub to_string {
+    my $this = shift;
+    return $this->{'name'}
+}
+
+sub TEXT		() { $_text }
+sub TEXT_PARAMETRIZED	() { $_text_parametrized }
+sub CDATA		() { $_cdata }
+sub TAG			() { $_tag }
+sub DECL		() { $_decl }
+sub PI			() { $_pi }
+sub DIRECTIVE		() { $_directive }
+sub COMMENT		() { $_comment }
+sub UNKNOWN		() { $_unknown }
+
+###############################################################################
+
+=over
+
+=item TEXT
+
+normal text (#text in the DTD)
+
+=item TEXT_PARAMETRIZED
+
+parametrized normal text
+(result of simple recognition of text interspersed with <TMPL_VAR> directives;
+this has to be explicitly enabled in the scanner)
+
+=item CDATA
+
+normal text (CDATA in the DTD)
+
+=item TAG
+
+something that has the form of an HTML tag
+
+=item DECL
+
+something that has the form of an SGML declaration
+
+=item PI
+
+something that has the form of an SGML processing instruction
+
+=item DIRECTIVE
+
+a HTML::Template directive (whether or not embedded in an SGML comment)
+
+=item COMMENT
+
+something that has the form of an HTML comment
+(and is not recognized as an HTML::Template directive)
+
+=item UNKNOWN
+
+something that is not recognized at all by the scanner
+
+=back
+
+Note that end of file is currently represented by undef,
+instead of a constant predefined by this module.
+
+=cut
+
+1;
diff --git a/l10n/TmplTokenizer.pm b/l10n/TmplTokenizer.pm
new file mode 100644
index 0000000..30d011d
--- /dev/null
+++ b/l10n/TmplTokenizer.pm
@@ -0,0 +1,1150 @@
+package TmplTokenizer;
+
+use strict;
+use TmplTokenType;
+use TmplToken;
+use VerboseWarnings qw( pedantic_p error_normal warn_normal warn_pedantic );
+require Exporter;
+
+use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
+
+###############################################################################
+
+=head1 NAME
+
+TmplTokenizer.pm - Simple-minded tokenizer class for HTML::Template .tmpl files
+
+=head1 DESCRIPTION
+
+Because .tmpl files contains HTML::Template directives
+that tend to confuse real parsers (e.g., HTML::Parse),
+it might be better to create a customized scanner
+to scan the template files for tokens.
+This module is a simple-minded attempt at such a scanner.
+
+=cut
+
+###############################################################################
+
+$VERSION = 0.02;
+
+@ISA = qw(Exporter);
+@EXPORT_OK = qw();
+
+use vars qw( $pedantic_attribute_error_in_nonpedantic_mode_p );
+use vars qw( $pedantic_tmpl_var_use_in_nonpedantic_mode_p );
+use vars qw( $pedantic_error_markup_in_pcdata_p );
+
+###############################################################################
+
+# Hideous stuff
+use vars qw( $re_directive $re_tmpl_var $re_tmpl_var_escaped $re_tmpl_include );
+use vars qw( $re_directive_control $re_tmpl_endif_endloop );
+BEGIN {
+    # $re_directive must not do any backreferences
+    $re_directive = q{<(?:(?i)(?:!--\s*)?\/?TMPL_(?:VAR|LOOP|INCLUDE|IF|ELSE|UNLESS)(?:\s+(?:[a-zA-Z][-a-zA-Z0-9]*=)?(?:'[^']*'|"[^"]*"|[^\s<>]+))*\s*(?:--)?)>};
+    # TMPL_VAR or TMPL_INCLUDE
+    $re_tmpl_var = q{<(?:(?i)(?:!--\s*)?TMPL_(?:VAR)(?:\s+(?:[a-zA-Z][-a-zA-Z0-9]*=)?(?:'[^']*'|"[^"]*"|[^\s<>]+))*\s*(?:--)?)>};
+    $re_tmpl_include = q{<(?:(?i)(?:!--\s*)?TMPL_(?:INCLUDE)(?:\s+(?:[a-zA-Z][-a-zA-Z0-9]*=)?(?:'[^']*'|"[^"]*"|[^\s<>]+))*\s*(?:--)?)>};
+    # TMPL_VAR ESCAPE=1/HTML/URL
+    $re_tmpl_var_escaped = q{<(?:(?i)(?:!--\s*)?TMPL_(?:VAR|INCLUDE)(?:\s+(?:[a-zA-Z][-a-zA-Z0-9]*=)?(?:'[^']*'|"[^"]*"|[^\s<>]+))\s+ESCAPE=(?:1|HTML|URL)(?:\s+(?:[a-zA-Z][-a-zA-Z0-9]*=)?(?:'[^']*'|"[^"]*"|[^\s<>]+))*\s*(?:--)?)>};
+    # Any control flow directive
+    $re_directive_control = q{<(?:(?i)(?:!--\s*)?\/?TMPL_(?:LOOP|IF|ELSE|UNLESS)(?:\s+(?:[a-zA-Z][-a-zA-Z0-9]*=)?(?:'[^']*'|"[^"]*"|[^\s<>]+))*\s*(?:--)?)>};
+    # /LOOP or /IF or /UNLESS
+    $re_tmpl_endif_endloop = q{<(?:(?i)(?:!--\s*)?\/TMPL_(?:LOOP|IF|UNLESS)(?:\s+(?:[a-zA-Z][-a-zA-Z0-9]*=)?(?:'[^']*'|"[^"]*"|[^\s<>]+))*\s*(?:--)?)>};
+}
+
+# Hideous stuff from subst.pl, slightly modified to use the above hideous stuff
+# Note: The $re_tag's set $1 (<tag), $2 (>), and $3 (rest of string)
+use vars qw( $re_comment $re_entity_name $re_end_entity $re_etag );
+use vars qw( $re_tag_strict $re_tag_compat @re_tag );
+sub re_tag ($) {
+   my($compat) = @_;
+   my $etag = $compat? '>': '<>\/';
+   # This is no longer similar to the original regexp in subst.pl :-(
+   # Note that we don't want <> in compat mode; Mozilla knows about <
+   q{(<\/?(?:|(?:"(?:} . $re_directive . q{|[^"])*"|'(?:} . $re_directive . q{|[^'])*'|--(?:(?!--)(?:$re_directive)*.)*--|(?:}
+   . $re_directive
+   . q{|(?!--)[^"'<>} . $etag . q{]))+))([} . $etag . q{]|(?=<))(.*)};
+}
+BEGIN {
+    $re_comment = '(?:--(?:[^-]|-[^-])*--)';
+    $re_entity_name = '(?:[^&%#;<>\s]+)'; # NOTE: not really correct SGML
+    $re_end_entity = '(?:;|$|(?=\s))'; # semicolon or before-whitespace
+    $re_etag = q{(?:<\/?(?:"[^"]*"|'[^']*'|[^"'>\/])*[>\/])}; # end-tag
+    @re_tag = ($re_tag_strict, $re_tag_compat) = (re_tag(0), re_tag(1));
+}
+
+# End of the hideous stuff
+
+use vars qw( $serial );
+
+###############################################################################
+
+sub FATAL_P		() {'fatal-p'}
+sub SYNTAXERROR_P	() {'syntaxerror-p'}
+
+sub FILENAME		() {'input'}
+sub HANDLE		() {'handle'}
+
+sub READAHEAD		() {'readahead'}
+sub LINENUM_START	() {'lc_0'}
+sub LINENUM		() {'lc'}
+sub CDATA_MODE_P	() {'cdata-mode-p'}
+sub CDATA_CLOSE		() {'cdata-close'}
+sub PCDATA_MODE_P	() {'pcdata-mode-p'}	# additional submode for CDATA
+sub JS_MODE_P		() {'js-mode-p'}	# cdata-mode-p must also be true
+
+sub ALLOW_CFORMAT_P	() {'allow-cformat-p'}
+
+sub new {
+    my $this = shift;
+    my($input) = @_;
+    my $class = ref($this) || $this;
+    my $self = {};
+    bless $self, $class;
+
+    my $handle = sprintf('TMPLTOKENIZER%d', $serial);
+    $serial += 1;
+
+    no strict;
+    open($handle, "<$input") || die "$input: $!\n";
+    use strict;
+    $self->{+FILENAME} = $input;
+    $self->{+HANDLE} = $handle;
+    $self->{+READAHEAD} = [];
+    return $self;
+}
+
+###############################################################################
+
+# Simple getters
+
+sub filename {
+    my $this = shift;
+    return $this->{+FILENAME};
+}
+
+sub _handle {
+    my $this = shift;
+    return $this->{+HANDLE};
+}
+
+sub fatal_p {
+    my $this = shift;
+    return $this->{+FATAL_P};
+}
+
+sub syntaxerror_p {
+    my $this = shift;
+    return $this->{+SYNTAXERROR_P};
+}
+
+sub has_readahead_p {
+    my $this = shift;
+    return @{$this->{+READAHEAD}};
+}
+
+sub _peek_readahead {
+    my $this = shift;
+    return $this->{+READAHEAD}->[$#{$this->{+READAHEAD}}];
+}
+
+sub line_number_start {
+    my $this = shift;
+    return $this->{+LINENUM_START};
+}
+
+sub line_number {
+    my $this = shift;
+    return $this->{+LINENUM};
+}
+
+sub cdata_mode_p {
+    my $this = shift;
+    return $this->{+CDATA_MODE_P};
+}
+
+sub pcdata_mode_p {
+    my $this = shift;
+    return $this->{+PCDATA_MODE_P};
+}
+
+sub js_mode_p {
+    my $this = shift;
+    return $this->{+JS_MODE_P};
+}
+
+sub cdata_close {
+    my $this = shift;
+    return $this->{+CDATA_CLOSE};
+}
+
+sub allow_cformat_p {
+    my $this = shift;
+    return $this->{+ALLOW_CFORMAT_P};
+}
+
+# Simple setters
+
+sub _set_fatal {
+    my $this = shift;
+    $this->{+FATAL_P} = $_[0];
+    return $this;
+}
+
+sub _set_syntaxerror {
+    my $this = shift;
+    $this->{+SYNTAXERROR_P} = $_[0];
+    return $this;
+}
+
+sub _push_readahead {
+    my $this = shift;
+    push @{$this->{+READAHEAD}}, $_[0];
+    return $this;
+}
+
+sub _pop_readahead {
+    my $this = shift;
+    return pop @{$this->{+READAHEAD}};
+}
+
+sub _append_readahead {
+    my $this = shift;
+    $this->{+READAHEAD}->[$#{$this->{+READAHEAD}}] .= $_[0];
+    return $this;
+}
+
+sub _set_readahead {
+    my $this = shift;
+    $this->{+READAHEAD}->[$#{$this->{+READAHEAD}}] = $_[0];
+    return $this;
+}
+
+sub _increment_line_number {
+    my $this = shift;
+    $this->{+LINENUM} += 1;
+    return $this;
+}
+
+sub _set_line_number_start {
+    my $this = shift;
+    $this->{+LINENUM_START} = $_[0];
+    return $this;
+}
+
+sub _set_cdata_mode {
+    my $this = shift;
+    $this->{+CDATA_MODE_P} = $_[0];
+    return $this;
+}
+
+sub _set_pcdata_mode {
+    my $this = shift;
+    $this->{+PCDATA_MODE_P} = $_[0];
+    return $this;
+}
+
+sub _set_js_mode {
+    my $this = shift;
+    $this->{+JS_MODE_P} = $_[0];
+    return $this;
+}
+
+sub _set_cdata_close {
+    my $this = shift;
+    $this->{+CDATA_CLOSE} = $_[0];
+    return $this;
+}
+
+sub set_allow_cformat {
+    my $this = shift;
+    $this->{+ALLOW_CFORMAT_P} = $_[0];
+    return $this;
+}
+
+###############################################################################
+
+use vars qw( $js_EscapeSequence );
+BEGIN {
+    # Perl quoting is really screwed up, but this common subexp is way too long
+    $js_EscapeSequence = q{\\\\(?:['"\\\\bfnrt]|[^0-7xu]|[0-3]?[0-7]{1,2}|x[\da-fA-F]{2}|u[\da-fA-F]{4})};
+}
+sub parenleft  () { '(' }
+sub parenright () { ')' }
+
+sub split_js ($) {
+    my ($s0) = @_;
+    my @it = ();
+    while (length $s0) {
+	if ($s0 =~ /^\s+/s) {				# whitespace
+	    push @it, $&;
+	    $s0 = $';
+	} elsif ($s0 =~ /^\/\/[^\r\n]*(?:[\r\n]|$)/s) {	# C++-style comment
+	    push @it, $&;
+	    $s0 = $';
+	} elsif ($s0 =~ /^\/\*(?:(?!\*\/).)*\*\//s) {	# C-style comment
+	    push @it, $&;
+	    $s0 = $';
+	# Keyword or identifier, ECMA-262 p.13 (section 7.5)
+	} elsif ($s0 =~ /^[A-Z_\$][A-Z\d_\$]*/is) {	# IdentifierName
+	    push @it, $&;
+	    $s0 = $';
+	# Punctuator, ECMA-262 p.13 (section 7.6)
+	} elsif ($s0 =~ /^(?:[\(\){}\[\];]|>>>=|<<=|>>=|[-\+\*\/\&\|\^\%]=|>>>|<<|>>|--|\+\+|\|\||\&\&|==|<=|>=|!=|[=><,!~\?:\.\-\+\*\/\&\|\^\%])/s) {
+	    push @it, $&;
+	    $s0 = $';
+	# DecimalLiteral, ECMA-262 p.14 (section 7.7.3); note: bug in the spec
+	} elsif ($s0 =~ /^(?:0|[1-9]\d+(?:\.\d*(?:[eE][-\+]?\d+)?)?)/s) {
+	    push @it, $&;
+	    $s0 = $';
+	# HexIntegerLiteral, ECMA-262 p.15 (section 7.7.3)
+	} elsif ($s0 =~ /^0[xX][\da-fA-F]+/s) {
+	    push @it, $&;
+	    $s0 = $';
+	# OctalIntegerLiteral, ECMA-262 p.15 (section 7.7.3)
+	} elsif ($s0 =~ /^0[\da-fA-F]+/s) {
+	    push @it, $&;
+	    $s0 = $';
+	# StringLiteral, ECMA-262 p.17 (section 7.7.4)
+	# XXX SourceCharacter doesn't seem to be defined (?)
+	} elsif ($s0 =~ /^(?:"(?:(?!["\\\r\n]).|$js_EscapeSequence)*"|'(?:(?!['\\\r\n]).|$js_EscapeSequence)*')/os) {
+	    push @it, $&;
+	    $s0 = $';
+	} elsif ($s0 =~ /^./) {				# UNKNOWN TOKEN !!!
+	    push @it, $&;
+	    $s0 = $';
+	}
+    }
+    return @it;
+}
+
+sub STATE_UNDERSCORE     () { 1 }
+sub STATE_PARENLEFT      () { 2 }
+sub STATE_STRING_LITERAL () { 3 }
+
+# XXX This is a crazy hack. I don't want to write an ECMAScript parser.
+# XXX A scanner is one thing; a parser another thing.
+sub identify_js_translatables (@) {
+    my @input = @_;
+    my @output = ();
+    # We mark a JavaScript translatable string as in C, i.e., _("literal")
+    # For simplicity, we ONLY look for "_" "(" StringLiteral ")"
+    for (my $i = 0, my $state = 0, my($j, $q, $s); $i <= $#input; $i += 1) {
+	my $reset_state_p = 0;
+	push @output, [0, $input[$i]];
+	if ($input[$i] !~ /\S/s) {
+	    ;
+	} elsif ($state == 0) {
+	    $state = STATE_UNDERSCORE if $input[$i] eq '_';
+	} elsif ($state == STATE_UNDERSCORE) {
+	    $state = $input[$i] eq parenleft ? STATE_PARENLEFT : 0;
+	} elsif ($state == STATE_PARENLEFT) {
+	    if ($input[$i] =~ /^(['"])(.*)\1$/s) {
+		($state, $j, $q, $s) = (STATE_STRING_LITERAL, $#output, $1, $2);
+	    } else {
+		$state = 0;
+	    }
+	} elsif ($state == STATE_STRING_LITERAL) {
+	    if ($input[$i] eq parenright) {
+		$output[$j] = [1, $output[$j]->[1], $q, $s];
+	    }
+	    $state = 0;
+	} else {
+	    die "identify_js_translatables internal error: Unknown state $state"
+	}
+    }
+    return \@output;
+}
+
+###############################################################################
+
+sub _extract_attributes ($;$) {
+    my $this = shift;
+    my($s, $lc) = @_;
+    my %attr;
+    $s = $1 if $s =~ /^<(?:(?!$re_directive_control)\S)+(.*)\/\S$/s	# XML-style self-closing tags
+	    || $s =~ /^<(?:(?!$re_directive_control)\S)+(.*)\S$/s;	# SGML-style tags
+
+    for (my $i = 0; $s =~ /^(?:$re_directive_control)?\s+(?:$re_directive_control)?(?:([a-zA-Z][-a-zA-Z0-9]*)\s*=\s*)?('((?:$re_directive|[^'])*)'|"((?:$re_directive|[^"])*)"|((?:$re_directive|[^\s<>])+))/os;) {
+	my($key, $val, $val_orig, $rest)
+		= ($1, (defined $3? $3: defined $4? $4: $5), $2, $');
+	$i += 1;
+	$attr{+lc($key)} = [$key, $val, $val_orig, $i];
+	$s = $rest;
+	if ($val =~ /$re_tmpl_include/os) {
+	    warn_normal "TMPL_INCLUDE in attribute: $val_orig\n", $lc;
+	} elsif ($val =~ /$re_tmpl_var/os && $val !~ /$re_tmpl_var_escaped/os) {
+	    # XXX: we probably should not warn if key is "onclick" etc
+	    # XXX: there's just no reasonable thing to suggest
+	    my $suggest = ($key =~ /^(?:action|archive|background|cite|classid|codebase|data|datasrc|for|href|longdesc|profile|src|usemap)$/i? 'URL': 'HTML');
+	    undef $suggest if $key =~ /^(?:onblur|onchange|onclick|ondblclick|onfocus|onkeydown|onkeypress|onkeyup|onload|onmousedown|onmousemove|onmouseout|onmouseover|onmouseup|onreset|onselect|onsubmit|onunload)$/i;
+	    warn_pedantic
+		    "Suggest ESCAPE=$suggest for TMPL_VAR in attribute \"$key\""
+			. ": $val_orig",
+		    $lc, \$pedantic_tmpl_var_use_in_nonpedantic_mode_p
+		if defined $suggest && (pedantic_p || !$pedantic_tmpl_var_use_in_nonpedantic_mode_p);
+	} elsif ($val_orig !~ /^['"]/) {
+	    my $t = $val; $t =~ s/$re_directive_control//os;
+	    warn_pedantic
+		"Unquoted attribute contains character(s) that should be quoted"
+		    . ": $val_orig",
+		$lc, \$pedantic_attribute_error_in_nonpedantic_mode_p
+		if $t =~ /[^-\.A-Za-z0-9]/s;
+	}
+    }
+    my $s2 = $s; $s2 =~ s/$re_tmpl_endif_endloop//g; # for the next check
+    if ($s2 =~ /\S/s) { # should never happen
+	if ($s =~ /^([^\n]*)\n/s) { # this is even worse
+	    error_normal("Completely confused while extracting attributes: $1", $lc);
+	    error_normal((scalar(split(/\n/, $s)) - 1) . " more line(s) not shown.", undef);
+	    $this->_set_fatal( 1 );
+	} else {
+	    # There's something wrong with the attribute syntax.
+	    # We might be able to deduce a likely cause by looking more.
+	    if ($s =~ /^[a-z0-9]/is && "<foo $s>" =~ /^$re_tag_compat$/s) {
+		warn_normal "Probably missing whitespace before or missing quotation mark near: $s\n", $lc;
+	    } else {
+		warn_normal "Strange attribute syntax: $s\n", $lc;
+	    }
+	}
+    }
+    return \%attr;
+}
+
+sub _next_token_internal {
+    my $this = shift;
+    my($h) = @_;
+    my($it, $kind);
+    my $eof_p = 0;
+    $this->_pop_readahead if $this->has_readahead_p
+	    && !ref $this->_peek_readahead
+	    && !length $this->_peek_readahead;
+    if (!$this->has_readahead_p) {
+	my $next = scalar <$h>;
+	$eof_p = !defined $next;
+	if (!$eof_p) {
+	    $this->_increment_line_number;
+	    $this->_push_readahead( $next );
+	}
+    }
+    $this->_set_line_number_start( $this->line_number ); # remember 1st line num
+    if ($this->has_readahead_p && ref $this->_peek_readahead) {	# TmplToken obj.
+	($it, $kind) = ($this->_pop_readahead, undef);
+    } elsif ($eof_p && !$this->has_readahead_p) {	# nothing left to do
+	;
+    } elsif ($this->_peek_readahead =~ /^\s+/s) {	# whitespace
+	($kind, $it) = (TmplTokenType::TEXT, $&);
+	$this->_set_readahead( $' );
+    # FIXME the following (the [<\s] part) is an unreliable HACK :-(
+    } elsif ($this->_peek_readahead =~ /^(?:[^<]|<[<\s])*(?:[^<\s])/s) {	# non-space normal text
+	($kind, $it) = (TmplTokenType::TEXT, $&);
+	$this->_set_readahead( $' );
+	warn_normal "Unescaped < in $it\n", $this->line_number_start
+		if !$this->cdata_mode_p && $it =~ /</s;
+    } else {				# tag/declaration/processing instruction
+	my $ok_p = 0;
+	my $bad_comment_p = 0;
+	for (my $cdata_close = $this->cdata_close;;) {
+	    if ($this->cdata_mode_p) {
+		my $next = $this->_pop_readahead;
+		if ($next =~ /^$cdata_close/is) {
+		    ($kind, $it) = (TmplTokenType::TAG, $&);
+		    $this->_push_readahead( $' );
+		    $ok_p = 1;
+		} elsif ($next =~ /^((?:(?!$cdata_close).)+)($cdata_close)/is) {
+		    ($kind, $it) = (TmplTokenType::TEXT, $1);
+		    $this->_push_readahead( "$2$'" );
+		    $ok_p = 1;
+		} else {
+		    ($kind, $it) = (TmplTokenType::TEXT, $next);
+		    $ok_p = 1;
+		}
+	    } elsif ($this->_peek_readahead =~ /^$re_tag_compat/os) {
+		# If we detect a "closed start tag" but we know that the
+		# following token looks like a TMPL_VAR, don't stop
+		my($head, $tail, $post) = ($1, $2, $3);
+		if ($tail eq '' && $post =~ $re_tmpl_var) {
+		    # Don't bother to show the warning if we're too confused
+		    # FIXME. There's no method for _closed_start_tag_warning
+		    if (!defined $this->{'_closed_start_tag_warning'}
+			|| ($this->{'_closed_start_tag_warning'}->[0] eq $head
+			&& $this->{'_closed_start_tag_warning'}->[1] != $this->line_number - 1)) {
+		    warn_normal "Possible SGML \"closed start tag\" notation: $head<\n", $this->line_number
+			    if split(/\n/, $head) < 10;
+		    }
+		    $this->{'_closed_start_tag_warning'} = [$head, $this->line_number];
+		} else {
+		    ($kind, $it) = (TmplTokenType::TAG, "$head>");
+		    $this->_set_readahead( $post );
+		    $ok_p = 1;
+		    warn_normal "SGML \"closed start tag\" notation: $head<\n", $this->line_number if $tail eq '';
+		}
+	    } elsif ($this->_peek_readahead =~ /^<!--(?:(?!-->)$re_directive*.)*-->/os) {
+		($kind, $it) = (TmplTokenType::COMMENT, $&);
+		$this->_set_readahead( $' );
+		$ok_p = 1;
+		$bad_comment_p = 1;
+	    }
+	last if $ok_p;
+	    my $next = scalar <$h>;
+	    $eof_p = !defined $next;
+	last if $eof_p;
+	    $this->_increment_line_number;
+	    $this->_append_readahead( $next );
+	}
+	if ($kind ne TmplTokenType::TAG) {
+	    ;
+	} elsif ($it =~ /^<!/) {
+	    $kind = TmplTokenType::DECL;
+	    $kind = TmplTokenType::COMMENT if $it =~ /^<!--(?:(?!-->).)*-->/;
+	    if ($kind == TmplTokenType::COMMENT && $it =~ /^<!--\s*#include/s) {
+		warn_normal "Apache #include directive found instead of HTML::Template <TMPL_INCLUDE> directive", $this->line_number_start;
+	    }
+	} elsif ($it =~ /^<\?/) {
+	    $kind = TmplTokenType::PI;
+	}
+	if ($it =~ /^$re_directive/ios && !$this->cdata_mode_p) {
+	    $kind = TmplTokenType::DIRECTIVE;
+	} elsif ($bad_comment_p) {
+	    warn_normal sprintf("Syntax error in comment: %s\n", $it),
+		    $this->line_number_start;
+	    $this->_set_syntaxerror( 1 );
+	}
+	if (!$ok_p && $eof_p) {
+	    ($kind, $it) = (TmplTokenType::UNKNOWN, $this->_peek_readahead);
+	    $this->_set_readahead, undef;
+	    $this->_set_syntaxerror( 1 );
+	}
+    }
+    warn_normal "Unrecognizable token found: "
+	    . (split(/\n/, $it) < 10? $it: '(too confused to show details)')
+	    . "\n", $this->line_number_start
+	if $kind == TmplTokenType::UNKNOWN;
+    return defined $it? (ref $it? $it: TmplToken->new($it, $kind, $this->line_number, $this->filename)): undef;
+}
+
+sub _next_token_intermediate {
+    my $this = shift;
+    my $h = $this->_handle;
+    my $it;
+    if (!$this->cdata_mode_p) {
+	$it = $this->_next_token_internal($h);
+	if (defined $it && $it->type == TmplTokenType::TAG) {
+	    if ($it->string =~ /^<(script|style|textarea)\b/is) {
+		$this->_set_cdata_mode( 1 );
+		$this->_set_cdata_close( "</$1\\s*>" );
+		$this->_set_pcdata_mode( 0 );
+		$this->_set_js_mode( lc($1) eq 'script' );
+#	    } elsif ($it->string =~ /^<(title)\b/is) {
+#		$this->_set_cdata_mode( 1 );
+#		$this->_set_cdata_close( "</$1\\s*>" );
+#		$this->_set_pcdata_mode( 1 );
+	    }
+	    $it->set_attributes( $this->_extract_attributes($it->string, $it->line_number) );
+	}
+    } else {
+	my $eof_p = 0;
+	for ($it = '', my $cdata_close = $this->cdata_close;;) {
+	    my $next = $this->_next_token_internal($h);
+	    $eof_p = !defined $next;
+	last if $eof_p;
+	    if (defined $next && $next->string =~ /$cdata_close/is) {
+		$this->_push_readahead( $next ); # push entire TmplToken object
+		$this->_set_cdata_mode( 0 );
+	    }
+	last unless $this->cdata_mode_p;
+	    $it .= $next->string;
+	}
+	if ($eof_p) {
+	    $it = undef;
+	    error_normal "Unexpected end of file while looking for "
+		    . $this->cdata_close
+		    . "\n", $this->line_number_start;
+	    $this->_set_fatal( 1 );
+	    $this->_set_syntaxerror( 1 );
+	}
+	if ($this->pcdata_mode_p) {
+	    my $check = $it;
+	    $check =~ s/$re_directive//gos;
+	    warn_pedantic "Markup found in PCDATA\n", $this->line_number,
+			    \$pedantic_error_markup_in_pcdata_p
+		    if $check =~ /$re_tag_compat/s;
+	}
+	# PCDATA should be treated as text, not CDATA
+	# Actually it should be treated as TEXT_PARAMETRIZED :-(
+	$it = TmplToken->new( $it,
+			($this->pcdata_mode_p?
+			    TmplTokenType::TEXT: TmplTokenType::CDATA),
+			$this->line_number, $this->filename )
+		if defined $it;
+	if ($this->js_mode_p) {
+	    my $s0 = $it->string;
+	    my @head = ();
+	    my @tail = ();
+	    if ($s0 =~ /^(\s*<!--\s*)(.*)(\s*--\s*>\s*)$/s) {
+		push @head, $1;
+		push @tail, $3;
+		$s0 = $2;
+	    }
+	    push @head, split_js $s0;
+	    $it->set_js_data( identify_js_translatables(@head, @tail) );
+	}
+	$this->_set_pcdata_mode, 0;
+	$this->_set_cdata_close, undef unless !defined $it;
+    }
+    return $it;
+}
+
+sub _token_groupable1_p ($) { # as first token, groupable into TEXT_PARAMETRIZED
+    my($t) = @_;
+    return ($t->type == TmplTokenType::TEXT && $t->string !~ /^[,\.:\|\s]+$/is)
+	|| ($t->type == TmplTokenType::DIRECTIVE
+		&& $t->string =~ /^(?:$re_tmpl_var)$/os)
+	|| ($t->type == TmplTokenType::TAG
+		&& ($t->string =~ /^<(?:a|b|em|h[123456]|i|u)\b/is
+		|| ($t->string =~ /^<input\b/is
+		    && $t->attributes->{'type'}->[1] =~ /^(?:radio|text)$/is)
+		    ))
+}
+
+sub _token_groupable2_p ($) { # as other token, groupable into TEXT_PARAMETRIZED
+    my($t) = @_;
+    return ($t->type == TmplTokenType::TEXT && ($t->string =~ /^\s*$/s || $t->string !~ /^[\|\s]+$/is))
+	|| ($t->type == TmplTokenType::DIRECTIVE
+		&& $t->string =~ /^(?:$re_tmpl_var)$/os)
+	|| ($t->type == TmplTokenType::TAG
+		&& ($t->string =~ /^<\/?(?:a|b|em|h[123456]|i|u)\b/is
+		|| ($t->string =~ /^<input\b/is
+		    && $t->attributes->{'type'}->[1] =~ /^(?:radio|text)$/is)))
+}
+
+sub _quote_cformat ($) {
+    my($s) = @_;
+    $s =~ s/%/%%/g;
+    return $s;
+}
+
+sub string_canon ($) {
+    my($s) = @_;
+    if (1) { # FIXME
+	# Fold all whitespace into single blanks
+	$s =~ s/\s+/ /gs;
+    }
+    return $s;
+}
+
+sub _formalize_string_cformat ($) {
+    my($s) = @_;
+    return _quote_cformat string_canon $s;
+}
+
+sub _formalize ($) {
+    my($t) = @_;
+    return $t->type == TmplTokenType::DIRECTIVE? '%s':
+	   $t->type == TmplTokenType::TEXT?
+		   _formalize_string_cformat($t->string):
+	   $t->type == TmplTokenType::TAG?
+		   ($t->string =~ /^<a\b/is? '<a>':
+		    $t->string =~ /^<input\b/is? (
+			    lc $t->attributes->{'type'}->[1] eq 'text' ? '%S':
+			    '%p'):
+		    _quote_cformat($t->string)):
+	       _quote_cformat($t->string);
+}
+
+sub _optimize {
+    my $this = shift;
+    my @structure = @_;
+    my $undo_trailing_blanks = sub {
+		for (my $i = $#structure; $i >= 0; $i -= 1) {
+		last unless ($structure[$i]->type == TmplTokenType::TEXT && blank_p($structure[$i]->string)) ;#|| ($structure[$i]->type == TmplTokenType::TAG && $structure[$i]->string =~ /^<br\b/is);
+		    # Queue element structure: [reanalysis-p, token]
+		    push @{$this->{_queue}}, [1, pop @structure];
+		}
+	    };
+    &$undo_trailing_blanks;
+    while (@structure >= 2) {
+	my $something_done_p = 0;
+	# FIXME: If the last token is a close tag but there are no tags
+	# FIXME: before it, drop the close tag back into the queue. This
+	# FIXME: is an ugly hack to get rid of "foo %s</h1>" type mess.
+	if (@structure >= 2
+		&& $structure[$#structure]->type == TmplTokenType::TAG
+		&& $structure[$#structure]->string =~ /^<\//s) {
+	    my $has_other_tags_p = 0;
+	    for (my $i = 0; $i < $#structure; $i += 1) {
+		$has_other_tags_p = 1
+			if $structure[$i]->type == TmplTokenType::TAG;
+	    last if $has_other_tags_p;
+	    }
+	    if (!$has_other_tags_p) {
+		push @{$this->{_queue}}, [0, pop @structure]
+		&$undo_trailing_blanks;
+		$something_done_p = 1;
+	    }
+	}
+	# FIXME: Do the same ugly hack for the last token being a ( or [
+	if (@structure >= 2
+		&& $structure[$#structure]->type == TmplTokenType::TEXT
+		&& $structure[$#structure]->string =~ /^[\(\[]$/) { # not )]
+	    push @{$this->{_queue}}, [1, pop @structure];
+	    &$undo_trailing_blanks;
+	    $something_done_p = 1;
+	}
+	# FIXME: If the first token is an open tag, but there is no
+	# FIXME: corresponding close tag, "drop the open tag", i.e.,
+	# FIXME: requeue everything for reanalysis, except the frist tag. :-(
+	if (@structure >= 2
+		&& $structure[0]->type == TmplTokenType::TAG
+		&& $structure[0]->string =~ /^<([a-z0-9]+)/is
+		&& (my $tag = $1) !~ /^(?:br|hr|img|input)\b/is
+	) {
+	    my $tag_open_count = 1;
+	    for (my $i = 1; $i <= $#structure; $i += 1) {
+		if ($structure[$i]->type == TmplTokenType::TAG) {
+		    if ($structure[$i]->string =~ /^<(\/?)$tag\b/is) {
+			$tag_open_count += ($1? -1: +1);
+		    }
+		}
+	    }
+	    if ($tag_open_count > 0) {
+		for (my $i = $#structure; $i; $i -= 1) {
+		    push @{$this->{_queue}}, [1, pop @structure];
+		}
+		$something_done_p = 1;
+	    }
+	}
+	# FIXME: If the first token is an open tag, the last token is the
+	# FIXME: corresponding close tag, and there are no other close tags 
+	# FIXME: inbetween, requeue the tokens from the second token on,
+	# FIXME: flagged as ok for re-analysis
+	if (@structure >= 3
+		&& $structure[0]->type == TmplTokenType::TAG
+		&& $structure[0]->string =~ /^<([a-z0-9]+)/is && (my $tag = $1)
+		&& $structure[$#structure]->type == TmplTokenType::TAG
+		&& $structure[$#structure]->string =~ /^<\/$1\s*>$/is) {
+	    my $has_other_open_or_close_tags_p = 0;
+	    for (my $i = 1; $i < $#structure; $i += 1) {
+		$has_other_open_or_close_tags_p = 1
+			if $structure[$i]->type == TmplTokenType::TAG
+			&& $structure[$i]->string =~ /^<\/?$tag\b/is;
+	    last if $has_other_open_or_close_tags_p;
+	    }
+	    if (!$has_other_open_or_close_tags_p) {
+		for (my $i = $#structure; $i; $i -= 1) {
+		    push @{$this->{_queue}}, [1, pop @structure];
+		}
+		$something_done_p = 1;
+	    }
+	}
+    last if !$something_done_p;
+    }
+    return @structure;
+}
+
+sub looks_plausibly_like_groupable_text_p (@) {
+    my @structure = @_;
+    # The text would look plausibly groupable if all open tags are also closed.
+    my @tags = ();
+    my $error_p = 0;
+    for (my $i = 0; $i <= $#structure; $i += 1) {
+	if ($structure[$i]->type == TmplTokenType::TAG) {
+	    my $form = $structure[$i]->string;
+	    if ($form =~ /^<([A-Z0-9]+)/is) {
+		my $tag = lc($1);
+		if ($tag !~ /^(?:br|input)$/is && $form !~ /\/>$/is) {
+		    push @tags, $tag;
+		}
+	    } elsif ($form =~ /^<\/([A-Z0-9]+)/is) {
+		if (@tags && lc($1) eq $tags[$#tags]) {
+		    pop @tags;
+		} else {
+		    $error_p = 1;
+		}
+	    }
+	} elsif ($structure[$i]->type != TmplTokenType::TEXT) {
+	    $error_p = 1;
+	}
+    last if $error_p;
+    }
+    return !$error_p && !@tags;
+}
+
+sub next_token {
+    my $this = shift;
+    my $h = $this->_handle;
+    my $it;
+    $this->{_queue} = [] unless defined $this->{_queue};
+
+    # Elements in the queue are ordered pairs. The first in the ordered pair
+    # specifies whether we are allowed to reanalysis; the second is the token.
+    if (@{$this->{_queue}} && !$this->{_queue}->[$#{$this->{_queue}}]->[0]) {
+	$it = (pop @{$this->{_queue}})->[1];
+    } else {
+	if (@{$this->{_queue}}) {
+	    $it = (pop @{$this->{_queue}})->[1];
+	} else {
+	    $it = $this->_next_token_intermediate($h);
+	}
+	if (!$this->cdata_mode_p && $this->allow_cformat_p && defined $it
+	    && ($it->type == TmplTokenType::TEXT?
+		!blank_p( $it->string ): _token_groupable1_p( $it ))) {
+	    my @structure = ( $it );
+	    my @tags = ();
+	    my $next = undef;
+	    my($nonblank_text_p, $parametrized_p, $with_anchor_p, $with_input_p) = (0, 0, 0, 0);
+	    if ($it->type == TmplTokenType::TEXT) {
+		$nonblank_text_p = 1 if !blank_p( $it->string );
+	    } elsif ($it->type == TmplTokenType::DIRECTIVE) {
+		$parametrized_p = 1;
+	    } elsif ($it->type == TmplTokenType::TAG && $it->string =~ /^<([A-Z0-9]+)/is) {
+		my $tag = lc($1);
+		push @tags, $tag if $tag !~ /^(?:br|input)$/i;
+		$with_anchor_p = 1 if $tag eq 'a';
+		$with_input_p = 1 if $tag eq 'input';
+	    }
+	    # We hate | and || in msgid strings, so we try to avoid them
+	    for (my $i = 1, my $quit_p = 0, my $quit_next_p = ($it->type == TmplTokenType::TEXT && $it->string =~ /^\|+$/s);; $i += 1) {
+		if (@{$this->{_queue}}) {
+		    $next = (pop @{$this->{_queue}})->[1];
+		} else {
+		    $next = $this->_next_token_intermediate($h);
+		}
+		push @structure, $next; # for consistency (with initialization)
+	    last unless defined $next && _token_groupable2_p( $next );
+	    last if $quit_next_p;
+		if ($next->type == TmplTokenType::TEXT) {
+		    $nonblank_text_p = 1 if !blank_p( $next->string );
+		    $quit_p = 1 if $next->string =~ /^\|+$/s; # We hate | and ||
+		} elsif ($next->type == TmplTokenType::DIRECTIVE) {
+		    $parametrized_p = 1;
+		} elsif ($next->type == TmplTokenType::TAG) {
+		    if ($next->string =~ /^<([A-Z0-9]+)/is) {
+			my $tag = lc($1);
+			push @tags, $tag if $tag !~ /^(?:br|input)$/i;
+			$with_anchor_p = 1 if $tag eq 'a';
+			$with_input_p = 1 if $tag eq 'input';
+		    } elsif ($next->string =~ /^<\/([A-Z0-9]+)/is) {
+			my $close = lc($1);
+			$quit_p = 1 unless @tags && $close eq $tags[$#tags];
+			$quit_next_p = 1 if $close =~ /^h\d$/;
+			pop @tags;
+		    }
+		}
+	    last if $quit_p;
+	    }
+	    # Undo the last token, allowing reanalysis
+	    push @{$this->{_queue}}, [1, pop @structure];
+	    # Simply it a bit more
+	    @structure = $this->_optimize( @structure );
+	    if (@structure < 2) {
+		# Nothing to do
+		;
+	    } elsif ($nonblank_text_p && ($parametrized_p || $with_anchor_p || $with_input_p)) {
+		# Create the corresponding c-format string
+		my $string = join('', map { $_->string } @structure);
+		my $form = join('', map { _formalize $_ } @structure);
+		my($a_counter, $input_counter) = (0, 0);
+		$form =~ s/<a>/ $a_counter += 1, "<a$a_counter>" /egs;
+		$form =~ s/<input>/ $input_counter += 1, "<input$input_counter>" /egs;
+		$it = TmplToken->new($string, TmplTokenType::TEXT_PARAMETRIZED,
+			$it->line_number, $it->pathname);
+		$it->set_form( $form );
+		$it->set_children( @structure );
+	    } elsif ($nonblank_text_p
+		    && looks_plausibly_like_groupable_text_p( @structure )
+		    && $structure[$#structure]->type == TmplTokenType::TEXT) {
+		# Combine the strings
+		my $string = join('', map { $_->string } @structure);
+		$it = TmplToken->new($string, TmplTokenType::TEXT,
+			$it->line_number, $it->pathname);;
+	    } else {
+		# Requeue the tokens thus seen for re-emitting, allow reanalysis
+		for (;;) {
+		    push @{$this->{_queue}}, [1, pop @structure];
+		last if !@structure;
+		}
+		$it = (pop @{$this->{_queue}})->[1];
+	    }
+	}
+    }
+    if (defined $it && $it->type == TmplTokenType::TEXT) {
+	my $form = string_canon $it->string;
+	$it->set_form( $form );
+    }
+    return $it;
+}
+
+###############################################################################
+
+# Other simple functions (These are not methods)
+
+sub blank_p ($) {
+    my($s) = @_;
+    return $s =~ /^(?:\s|\&nbsp$re_end_entity|$re_tmpl_var)*$/os;
+}
+
+sub trim ($) {
+    my($s0) = @_;
+    my $l0 = length $s0;
+    my $s = $s0;
+    $s =~ s/^(\s|\&nbsp$re_end_entity)+//os; my $l1 = $l0 - length $s;
+    $s =~ s/(\s|\&nbsp$re_end_entity)+$//os; my $l2 = $l0 - $l1 - length $s;
+    return wantarray? (substr($s0, 0, $l1), $s, substr($s0, $l0 - $l2)): $s;
+}
+
+sub quote_po ($) {
+    my($s) = @_;
+    # Locale::PO->quote is buggy, it doesn't quote newlines :-/
+    $s =~ s/([\\"])/\\\1/gs;
+    $s =~ s/\n/\\n/g;
+    #$s =~ s/[\177-\377]/ sprintf("\\%03o", ord($&)) /egs;
+    return "\"$s\"";
+}
+
+# Some functions that shouldn't be here... should be moved out some time
+sub parametrize ($$$$) {
+    my($fmt_0, $cformat_p, $t, $f) = @_;
+    my $it = '';
+    if ($cformat_p) {
+	my @params = $t->parameters_and_fields;
+	for (my $n = 0, my $fmt = $fmt_0; length $fmt;) {
+	    if ($fmt =~ /^[^%]+/) {
+		$fmt = $';
+		$it .= $&;
+	    } elsif ($fmt =~ /^%%/) {
+		$fmt = $';
+		$it .= '%';
+	    } elsif ($fmt =~ /^%(?:(\d+)\$)?(?:(\d+)(?:\.(\d+))?)?s/s) {
+		$n += 1;
+		my($i, $width, $prec) = ((defined $1? $1: $n), $2, $3);
+		$fmt = $';
+		if (defined $width && defined $prec && !$width && !$prec) {
+		    ;
+		} elsif (defined $params[$i - 1]) {
+		    my $param = $params[$i - 1];
+		    warn_normal "$fmt_0: $&: Expected a TMPL_VAR, but found a "
+			    . $param->type->to_string . "\n", undef
+			    if $param->type != TmplTokenType::DIRECTIVE;
+		    warn_normal "$fmt_0: $&: Unsupported "
+				. "field width or precision\n", undef
+			    if defined $width || defined $prec;
+		    warn_normal "$fmt_0: $&: Parameter $i not known", undef
+			    unless defined $param;
+		    $it .= defined $f? &$f( $param ): $param->string;
+		}
+	    } elsif ($fmt =~ /^%(?:(\d+)\$)?(?:(\d+)(?:\.(\d+))?)?([pS])/s) {
+		$n += 1;
+		my($i, $width, $prec, $conv) = ((defined $1? $1: $n), $2, $3, $4);
+		$fmt = $';
+
+		my $param = $params[$i - 1];
+		if (!defined $param) {
+		    warn_normal "$fmt_0: $&: Parameter $i not known", undef;
+		} else {
+		    if ($param->type == TmplTokenType::TAG
+			    && $param->string =~ /^<input\b/is) {
+			my $type = defined $param->attributes?
+				lc($param->attributes->{'type'}->[1]): undef;
+			if ($conv eq 'S') {
+			    warn_normal "$fmt_0: $&: Expected type=text, "
+					. "but found type=$type", undef
+				    unless $type eq 'text';
+			} elsif ($conv eq 'p') {
+			    warn_normal "$fmt_0: $&: Expected type=radio, "
+					. "but found type=$type", undef
+				    unless $type eq 'radio';
+			}
+		    } else {
+			warn_normal "$&: Expected an INPUT, but found a "
+				. $param->type->to_string . "\n", undef
+		    }
+		    warn_normal "$fmt_0: $&: Unsupported "
+				. "field width or precision\n", undef
+			    if defined $width || defined $prec;
+		    $it .= defined $f? &$f( $param ): $param->string;
+		}
+	    } elsif ($fmt =~ /^%[^%a-zA-Z]*[a-zA-Z]/) {
+		$fmt = $';
+		$it .= $&;
+		die "$&: Unknown or unsupported format specification\n"; #XXX
+	    } else {
+		die "$&: Completely confused parametrizing\n";#XXX
+	    }
+	}
+    }
+    my @anchors = $t->anchors;
+    for (my $n = 0, my $fmt = $it, $it = ''; length $fmt;) {
+	if ($fmt =~ /^(?:(?!<a\d+>).)+/is) {
+	    $fmt = $';
+	    $it .= $&;
+	} elsif ($fmt =~ /^<a(\d+)>/is) {
+	    $n += 1;
+	    my $i  = $1;
+	    $fmt = $';
+	    my $anchor = $anchors[$i - 1];
+	    warn_normal "$&: Anchor $1 not found for msgid \"$fmt_0\"", undef #FIXME
+		    unless defined $anchor;
+	    $it .= $anchor->string;
+	} else {
+	    die "Completely confused decoding anchors: $fmt\n";#XXX
+	}
+    }
+    return $it;
+}
+
+sub charset_canon ($) {
+    my($charset) = @_;
+    $charset = uc($charset);
+    $charset = "$1-$2" if $charset =~ /^(ISO|UTF)(\d.*)/i;
+    $charset = 'Big5' if $charset eq 'BIG5'; # "Big5" must be in mixed case
+    return $charset;
+}
+
+use vars qw( @latin1_utf8 );
+@latin1_utf8 = (
+    "\302\200", "\302\201", "\302\202", "\302\203", "\302\204", "\302\205",
+    "\302\206", "\302\207", "\302\210", "\302\211", "\302\212", "\302\213",
+    "\302\214", "\302\215",   undef,      undef,    "\302\220", "\302\221",
+    "\302\222", "\302\223", "\302\224", "\302\225", "\302\226", "\302\227",
+    "\302\230", "\302\231", "\302\232", "\302\233", "\302\234", "\302\235",
+    "\302\236", "\302\237", "\302\240", "\302\241", "\302\242", "\302\243",
+    "\302\244", "\302\245", "\302\246", "\302\247", "\302\250", "\302\251",
+    "\302\252", "\302\253", "\302\254", "\302\255", "\302\256", "\302\257",
+    "\302\260", "\302\261", "\302\262", "\302\263", "\302\264", "\302\265",
+    "\302\266", "\302\267", "\302\270", "\302\271", "\302\272", "\302\273",
+    "\302\274", "\302\275", "\302\276", "\302\277", "\303\200", "\303\201",
+    "\303\202", "\303\203", "\303\204", "\303\205", "\303\206", "\303\207",
+    "\303\210", "\303\211", "\303\212", "\303\213", "\303\214", "\303\215",
+    "\303\216", "\303\217", "\303\220", "\303\221", "\303\222", "\303\223",
+    "\303\224", "\303\225", "\303\226", "\303\227", "\303\230", "\303\231",
+    "\303\232", "\303\233", "\303\234", "\303\235", "\303\236", "\303\237",
+    "\303\240", "\303\241", "\303\242", "\303\243", "\303\244", "\303\245",
+    "\303\246", "\303\247", "\303\250", "\303\251", "\303\252", "\303\253",
+    "\303\254", "\303\255", "\303\256", "\303\257", "\303\260", "\303\261",
+    "\303\262", "\303\263", "\303\264", "\303\265", "\303\266", "\303\267",
+    "\303\270", "\303\271", "\303\272", "\303\273", "\303\274", "\303\275",
+    "\303\276", "\303\277" );
+
+sub charset_convert ($$$) {
+    my($s, $charset_in, $charset_out) = @_;
+    if ($s !~ /[\200-\377]/s) { # FIXME: don't worry about iso2022 for now
+	;
+    } elsif ($charset_in eq 'ISO-8859-1' && $charset_out eq 'UTF-8') {
+	$s =~ s/[\200-\377]/ $latin1_utf8[ord($&) - 128] /egs;
+    } elsif ($charset_in ne $charset_out) {
+	VerboseWarnings::warn_normal "conversion from $charset_in to $charset_out is not supported\n", undef;
+    }
+    return $s;
+}
+
+###############################################################################
+
+=pod
+
+In addition to the basic scanning, this class will also perform
+the following:
+
+=over
+
+=item -
+
+Emulation of c-format strings (see below)
+
+=item -
+
+Display of warnings for certain things that affects either the
+ability of this class to yield correct output, or things that
+are known to cause the original template to cause trouble.
+
+=item -
+
+Automatic correction of some of the things warned about
+(e.g., SGML "closed start tag" notation).
+
+=back
+
+=head2 c-format strings emulation
+
+Because English word order is not universal, a simple extraction
+of translatable strings may yield some strings like "Accounts for"
+or ambiguous strings like "in". This makes the resulting strings
+difficult to translate, but does not affect all languages alike.
+For example, Chinese (with a somewhat different word order) would
+be hit harder, but French would be relatively unaffected.
+
+To overcome this problem, the scanner can be configured to detect
+patterns with <TMPL_VAR> directives (as well as certain HTML tags),
+and try to construct a larger pattern that will appear in the PO
+file as c-format strings with %s placeholders. This additional
+step allows the translator to deal with cases where word order
+is different (replacing %s with %1$s, %2$s, etc.), or when certain
+words will require certain inflectional suffixes in sentences.
+
+Because this is an incompatible change, this mode must be explicitly
+turned on using the set_cformat(1) method call.
+
+=head2 The flag characters
+
+The character % is followed by zero or more of the following flags:
+
+=over
+
+=item #
+
+The value comes from HTML <INPUT> elements.
+This abuse of the flag character is somewhat reasonable,
+since TMPL_VAR and INPUT are both variables, but of different kinds.
+
+=back
+
+=head2 The field width and precision
+
+An optional 0.0 can be specified for %s to specify
+that the <TMPL_VAR> should be suppressed.
+
+=head2 The conversion specifier
+
+=over
+
+=item p
+
+Specifies any input field that is neither text nor hidden
+(which currently mean radio buttons).
+The p conversion specifier is chosen because this does not
+evoke any certain sensible data type.
+
+=item S
+
+Specifies a text input field (<INPUT TYPE=TEXT>).
+This use of the S conversion specifier is somewhat reasonable,
+since text input fields contain values of undeterminable type,
+which can be treated as strings.
+
+=item s
+
+Specifies a <TMPL_VAR>.
+This use of the o conversion specifier is somewhat reasonable,
+since <TMPL_VAR> denotes values of undeterminable type, which
+can be treated as strings.
+
+=back
+
+=head1 BUGS
+
+There is no code to save the tag name anywhere in the scanned token.
+
+The use of <AI<i>> to stand for the I<i>th anchor
+is not very well thought out.
+Some abuse of c-format specifies might have been more appropriate.
+
+=head1 HISTORY
+
+This tokenizer is mostly based
+on Ambrose's hideous Perl script known as subst.pl.
+
+=cut
+
+1;
diff --git a/l10n/VerboseWarnings.pm b/l10n/VerboseWarnings.pm
new file mode 100644
index 0000000..05fd9e5
--- /dev/null
+++ b/l10n/VerboseWarnings.pm
@@ -0,0 +1,127 @@
+package VerboseWarnings;
+
+use strict;
+require Exporter;
+
+use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
+
+###############################################################################
+
+=head1 NAME
+
+VerboseWarnings.pm - Verbose warnings for Perl scripts
+
+=head1 DESCRIPTION
+
+Contains convenience functions to construct Unix-style informational,
+verbose warnings.
+
+=cut
+
+###############################################################################
+
+$VERSION = 0.01;
+
+@ISA = qw(Exporter);
+@EXPORT_OK = qw(
+    &pedantic_p
+    &warn_additional
+    &warn_normal
+    &warn_pedantic
+    &error_additional
+    &error_normal
+);
+%EXPORT_TAGS = (
+    'warn' => [ 'warn_additional',  'warn_normal',  'warn_pedantic' ],
+    'die'  => [ 'error_additional', 'error_normal' ],
+);
+
+###############################################################################
+
+use vars qw( $appName $input $input_abbr $pedantic_p $pedantic_tag $quiet);
+use vars qw( $warned $erred );
+
+sub set_application_name ($) {
+    my($s) = @_;
+    $appName = $& if !defined $appName && $s =~ /[^\/]+$/;
+}
+
+sub application_name () {
+    return $appName;
+}
+
+sub set_input_file_name ($) {
+    my($s) = @_;
+    $input = $s;
+    $input_abbr = $& if defined $s && $s =~ /[^\/]+$/;
+}
+
+sub set_pedantic_mode ($) {
+    my($p) = @_;
+    $pedantic_p = $p;
+    $pedantic_tag = $pedantic_p? '': ' (negligible)';
+}
+
+sub pedantic_p () {
+    return $pedantic_p;
+}
+
+sub construct_warn_prefix ($$) {
+    my($prefix, $lc) = @_;
+    die "construct_warn_prefix called before set_application_name"
+	    unless defined $appName;
+    die "construct_warn_prefix called before set_input_file_name"
+	    unless defined $input || !defined $lc; # be a bit lenient
+    die "construct_warn_prefix called before set_pedantic_mode"
+	    unless defined $pedantic_tag;
+
+    # FIXME: The line number is not accurate, but should be "close enough"
+    # FIXME: This wording is worse than what was there, but it's wrong to
+    # FIXME: hard-code this thing in each warn statement. Need improvement.
+    return "$appName: $prefix: " . (defined $lc? "$input_abbr: line $lc: ": defined $input_abbr? "$input_abbr: ": '');
+}
+
+sub warn_additional ($$) {
+    my($msg, $lc) = @_;
+    my $prefix = construct_warn_prefix('Warning', $lc);
+    $msg .= "\n" unless $msg =~ /\n$/s;
+    warn "$prefix$msg";
+}
+
+sub warn_normal ($$) {
+    my($msg, $lc) = @_;
+    $warned += 1;
+    warn_additional($msg, $lc);
+}
+
+sub warn_pedantic ($$$) {
+    my($msg, $lc, $flag) = @_;
+    my $prefix = construct_warn_prefix("Warning$pedantic_tag", $lc);
+    $msg .= "\n" unless $msg =~ /\n$/s;
+    warn "$prefix$msg" if ($pedantic_p || !$$flag) && $quiet;
+    if (!$pedantic_p) {
+	$prefix = construct_warn_prefix("Warning$pedantic_tag", undef);
+	warn $prefix."Further similar negligible warnings will not be reported, use --pedantic for details\n" unless ($$flag || !$quiet);
+	$$flag = 1;
+    }
+    $warned += 1;
+}
+
+sub error_additional ($$) {
+    my($msg, $lc) = @_;
+    my $prefix = construct_warn_prefix('ERROR', $lc);
+    $msg .= "\n" unless $msg =~ /\n$/s;
+    warn "$prefix$msg";
+}
+
+sub error_normal ($$) {
+    my($msg, $lc) = @_;
+    $erred += 1;
+    error_additional($msg, $lc);
+}
+
+sub warned () {
+    return $warned; # number of times warned
+}
+
+###############################################################################
diff --git a/l10n/tmpl_process3.pl b/l10n/tmpl_process3.pl
new file mode 100755
index 0000000..b8451b5
--- /dev/null
+++ b/l10n/tmpl_process3.pl
@@ -0,0 +1,514 @@
+#!/usr/bin/perl
+# This file is part of Koha
+# Parts copyright 2003-2004 Paul Poulain
+# Parts copyright 2003-2004 Jerome Vizcaino
+# Parts copyright 2004 Ambrose Li
+
+=head1 NAME
+
+tmpl_process3.pl - Alternative version of tmpl_process.pl
+using gettext-compatible translation files
+
+=cut
+
+use strict;
+use Getopt::Long;
+use Locale::PO;
+use File::Temp qw( :POSIX );
+use TmplTokenizer;
+use VerboseWarnings qw( :warn :die );
+
+###############################################################################
+
+use vars qw( @in_files $in_dir $str_file $out_dir $quiet );
+use vars qw( @excludes $exclude_regex );
+use vars qw( $recursive_p );
+use vars qw( $pedantic_p );
+use vars qw( $href );
+use vars qw( $type );	# file extension (DOS form without the dot) to match
+use vars qw( $charset_in $charset_out );
+
+###############################################################################
+
+sub find_translation ($) {
+    my($s) = @_;
+    my $key = $s;
+    if ($s =~ /\S/s) {
+	$key = TmplTokenizer::string_canon($key);
+	$key = TmplTokenizer::charset_convert($key, $charset_in, $charset_out);
+	$key = TmplTokenizer::quote_po($key);
+    }
+    return defined $href->{$key}
+		&& !$href->{$key}->fuzzy
+		&& length Locale::PO->dequote($href->{$key}->msgstr)?
+	   Locale::PO->dequote($href->{$key}->msgstr): $s;
+}
+
+sub text_replace_tag ($$) {
+    my($t, $attr) = @_;
+    my $it;
+    # value [tag=input], meta
+    my $tag = lc($1) if $t =~ /^<(\S+)/s;
+    my $translated_p = 0;
+    for my $a ('alt', 'content', 'title', 'value') {
+	if ($attr->{$a}) {
+	    next if $a eq 'content' && $tag ne 'meta';
+	    next if $a eq 'value' && ($tag ne 'input'
+		|| (ref $attr->{'type'} && $attr->{'type'}->[1] =~ /^(?:hidden|radio|text)$/)); # FIXME
+	    my($key, $val, $val_orig, $order) = @{$attr->{$a}}; #FIXME
+	    if ($val =~ /\S/s) {
+		my $s = find_translation($val);
+		if ($attr->{$a}->[1] ne $s) { #FIXME
+		    $attr->{$a}->[1] = $s; # FIXME
+		    $attr->{$a}->[2] = ($s =~ /"/s)? "'$s'": "\"$s\""; #FIXME
+		    $translated_p = 1;
+		}
+	    }
+	}
+    }
+    if ($translated_p) {
+	$it = "<$tag"
+	    . join('', map {
+		    sprintf(' %s=%s', $_, $attr->{$_}->[2]) #FIXME
+		} sort {
+		    $attr->{$a}->[3] <=> $attr->{$b}->[3] #FIXME
+		} keys %$attr)
+	    . '>';
+    } else {
+	$it = $t;
+    }
+    return $it;
+}
+
+sub text_replace (**) {
+    my($h, $output) = @_;
+    for (;;) {
+	my $s = TmplTokenizer::next_token $h;
+    last unless defined $s;
+	my($kind, $t, $attr) = ($s->type, $s->string, $s->attributes);
+	if ($kind eq TmplTokenType::TEXT) {
+	    print $output find_translation($t);
+	} elsif ($kind eq TmplTokenType::TEXT_PARAMETRIZED) {
+	    my $fmt = find_translation($s->form);
+	    print $output TmplTokenizer::parametrize($fmt, 1, $s, sub {
+		$_ = $_[0];
+		my($kind, $t, $attr) = ($_->type, $_->string, $_->attributes);
+		$kind == TmplTokenType::TAG && %$attr?
+		    text_replace_tag($t, $attr): $t });
+	} elsif ($kind eq TmplTokenType::TAG && %$attr) {
+	    print $output text_replace_tag($t, $attr);
+	} elsif ($s->has_js_data) {
+	    for my $t (@{$s->js_data}) {
+		# FIXME for this whole block
+		if ($t->[0]) {
+		    printf $output "%s%s%s", $t->[2], find_translation $t->[3],
+			    $t->[2];
+		} else {
+		    print $output $t->[1];
+		}
+	    }
+	} elsif (defined $t) {
+	    print $output $t;
+	}
+    }
+}
+
+sub listfiles ($$$) {
+    my($dir, $type, $action) = @_;
+    my @it = ();
+    if (opendir(DIR, $dir)) {
+	my @dirent = readdir DIR;	# because DIR is shared when recursing
+	closedir DIR;
+	for my $dirent (@dirent) {
+	    my $path = "$dir/$dirent";
+	    if ($dirent =~ /^\./ || $dirent eq 'CVS' || $dirent eq 'RCS'
+	    || (defined $exclude_regex && $dirent =~ /^(?:$exclude_regex)$/)) {
+		;
+	    } elsif (-f $path) {
+		push @it, $path if (!defined $type || $dirent =~ /\.(?:$type)$/) || $action eq 'install';
+	    } elsif (-d $path && $recursive_p) {
+		push @it, listfiles($path, $type, $action);
+	    }
+	}
+    } else {
+	warn_normal "$dir: $!", undef;
+    }
+    return @it;
+}
+
+###############################################################################
+
+sub mkdir_recursive ($) {
+    my($dir) = @_;
+    local($`, $&, $', $1);
+    $dir = $` if $dir ne /^\/+$/ && $dir =~ /\/+$/;
+    my ($prefix, $basename) = ($dir =~ /\/([^\/]+)$/s)? ($`, $1): ('.', $dir);
+    mkdir_recursive($prefix) if $prefix ne '.' && !-d $prefix;
+    if (!-d $dir) {
+	print STDERR "Making directory $dir..." unless $quiet;
+	# creates with rwxrwxr-x permissions
+	mkdir($dir, 0775) || warn_normal "$dir: $!", undef;
+    }
+}
+
+###############################################################################
+
+sub usage ($) {
+    my($exitcode) = @_;
+    my $h = $exitcode? *STDERR: *STDOUT;
+    print $h <<EOF;
+Usage: $0 create [OPTION]
+  or:  $0 update [OPTION]
+  or:  $0 install [OPTION]
+  or:  $0 --help
+Create or update PO files from templates, or install translated templates.
+
+  -i, --input=SOURCE          Get or update strings from SOURCE file.
+                              SOURCE is a directory if -r is also specified.
+  -o, --outputdir=DIRECTORY   Install translation(s) to specified DIRECTORY
+      --pedantic-warnings     Issue warnings even for detected problems
+                              which are likely to be harmless
+  -r, --recursive             SOURCE in the -i option is a directory
+  -s, --str-file=FILE         Specify FILE as the translation (po) file
+                              for input (install) or output (create, update)
+  -x, --exclude=REGEXP        Exclude files matching the given REGEXP
+      --help                  Display this help and exit
+  -q, --quiet                 no output to screen (except for errors)
+
+The -o option is ignored for the "create" and "update" actions.
+Try `perldoc $0 for perhaps more information.
+EOF
+    exit($exitcode);
+}#`
+
+###############################################################################
+
+sub usage_error (;$) {
+    for my $msg (split(/\n/, $_[0])) {
+	print STDERR "$msg\n";
+    }
+    print STDERR "Try `$0 --help for more information.\n";
+    exit(-1);
+}
+
+###############################################################################
+
+GetOptions(
+    'input|i=s'				=> \@in_files,
+    'outputdir|o=s'			=> \$out_dir,
+    'recursive|r'			=> \$recursive_p,
+    'str-file|s=s'			=> \$str_file,
+    'exclude|x=s'			=> \@excludes,
+	'quiet|q'				=> \$quiet,
+    'pedantic-warnings|pedantic'	=> sub { $pedantic_p = 1 },
+    'help'				=> \&usage,
+) || usage_error;
+
+VerboseWarnings::set_application_name $0;
+VerboseWarnings::set_pedantic_mode $pedantic_p;
+
+# keep the buggy Locale::PO quiet if it says stupid things
+$SIG{__WARN__} = sub {
+	my($s) = @_;
+	print STDERR $s unless $s =~ /^Strange line in [^:]+: #~/s
+    };
+
+my $action = shift or usage_error('You must specify an ACTION.');
+usage_error('You must at least specify input and string list filenames.')
+    if !@in_files || !defined $str_file;
+
+# Type match defaults to *.tmpl plus *.inc if not specified
+$type = "tmpl|inc" if !defined($type);
+
+# Check the inputs for being files or directories
+for my $input (@in_files) {
+    usage_error("$input: Input must be a file or directory.\n"
+	    . "(Symbolic links are not supported at the moment)")
+	unless -d $input || -f $input;;
+}
+
+# Generates the global exclude regular expression
+$exclude_regex =  '(?:'.join('|', @excludes).')' if @excludes;
+
+# Generate the list of input files if a directory is specified
+if (-d $in_files[0]) {
+    die "If you specify a directory as input, you must specify only it.\n"
+	    if @in_files > 1;
+
+    # input is a directory, generates list of files to process
+    $in_dir = $in_files[0];
+    $in_dir =~ s/\/$//; # strips the trailing / if any
+    @in_files = listfiles($in_dir, $type, $action);
+} else {
+    for my $input (@in_files) {
+	die "You cannot specify input files and directories at the same time.\n"
+		unless -f $input;
+    }
+}
+
+# restores the string list from file
+$href = Locale::PO->load_file_ashash($str_file);
+
+# guess the charsets. HTML::Templates defaults to iso-8859-1
+if (defined $href) {
+    die "$str_file: PO file is corrupted, or not a PO file\n"
+	    unless defined $href->{'""'};
+    $charset_out = TmplTokenizer::charset_canon $2
+	    if $href->{'""'}->msgstr =~ /\bcharset=(["']?)([^;\s"'\\]+)\1/;
+    for my $msgid (keys %$href) {
+	if ($msgid =~ /\bcharset=(["']?)([^;\s"'\\]+)\1/) {
+	    my $candidate = TmplTokenizer::charset_canon $2;
+	    die "Conflicting charsets in msgid: $charset_in vs $candidate\n"
+		    if defined $charset_in && $charset_in ne $candidate;
+	    $charset_in = $candidate;
+	}
+    }
+}
+if (!defined $charset_in) {
+    $charset_in = TmplTokenizer::charset_canon 'iso8859-1';
+    warn "Warning: Can't determine original templates' charset, defaulting to $charset_in\n";
+}
+
+my $xgettext = './xgettext.pl';	# actual text extractor script
+my $st;
+
+if ($action eq 'create')  {
+    # updates the list. As the list is empty, every entry will be added
+    if (!-s $str_file) {
+	warn "Removing empty file $str_file\n";
+	unlink $str_file || die "$str_file: $!\n";
+    }
+    die "$str_file: Output file already exists\n" if -f $str_file;
+    my($tmph1, $tmpfile1) = tmpnam();
+    my($tmph2, $tmpfile2) = tmpnam();
+    close $tmph2; # We just want a name
+    # Generate the temporary file that acts as <MODULE>/POTFILES.in
+    for my $input (@in_files) {
+	print $tmph1 "$input\n";
+    }
+    close $tmph1;
+    # Generate the specified po file ($str_file)
+    $st = system ($xgettext, '-s', '-f', $tmpfile1, '-o', $tmpfile2);
+    # Run msgmerge so that the pot file looks like a real pot file
+    # We need to help msgmerge a bit by pre-creating a dummy po file that has
+    # the headers and the "" msgid & msgstr. It will fill in the rest.
+    if ($st == 0) {
+	# Merge the temporary "pot file" with the specified po file ($str_file)
+	# FIXME: msgmerge(1) is a Unix dependency
+	# FIXME: need to check the return value
+	unless (-f $str_file) {
+	    local(*INPUT, *OUTPUT);
+	    open(INPUT, "<$tmpfile2");
+	    open(OUTPUT, ">$str_file");
+	    while (<INPUT>) {
+		print OUTPUT;
+	    last if /^\n/s;
+	    }
+	    close INPUT;
+	    close OUTPUT;
+	}
+	$st = system('msgmerge', '-U', '-s', $str_file, $tmpfile2);
+    } else {
+	error_normal "Text extraction failed: $xgettext: $!\n", undef;
+	error_additional "Will not run msgmerge\n", undef;
+    }
+#   unlink $tmpfile1 || warn_normal "$tmpfile1: unlink failed: $!\n", undef;
+#   unlink $tmpfile2 || warn_normal "$tmpfile2: unlink failed: $!\n", undef;
+
+} elsif ($action eq 'update') {
+    my($tmph1, $tmpfile1) = tmpnam();
+    my($tmph2, $tmpfile2) = tmpnam();
+    close $tmph2; # We just want a name
+    # Generate the temporary file that acts as <MODULE>/POTFILES.in
+    for my $input (@in_files) {
+	print $tmph1 "$input\n";
+    }
+    close $tmph1;
+    # Generate the temporary file that acts as <MODULE>/<LANG>.pot
+    $st = system($xgettext, '-s', '-f', $tmpfile1, '-o', $tmpfile2,
+	    '--po-mode',
+	    (defined $charset_in? ('-I', $charset_in): ()),
+	    (defined $charset_out? ('-O', $charset_out): ()));
+    if ($st == 0) {
+	# Merge the temporary "pot file" with the specified po file ($str_file)
+	# FIXME: msgmerge(1) is a Unix dependency
+	# FIXME: need to check the return value
+	$st = system('msgmerge', '-U', '-s', $str_file, $tmpfile2);
+    } else {
+	error_normal "Text extraction failed: $xgettext: $!\n", undef;
+	error_additional "Will not run msgmerge\n", undef;
+    }
+#   unlink $tmpfile1 || warn_normal "$tmpfile1: unlink failed: $!\n", undef;
+#   unlink $tmpfile2 || warn_normal "$tmpfile2: unlink failed: $!\n", undef;
+
+} elsif ($action eq 'install') {
+    if(!defined($out_dir)) {
+	usage_error("You must specify an output directory when using the install method.");
+    }
+	
+    if ($in_dir eq $out_dir) {
+	warn "You must specify a different input and output directory.\n";
+	exit -1;
+    }
+
+    # Make sure the output directory exists
+    # (It will auto-create it, but for compatibility we should not)
+    -d $out_dir || die "$out_dir: The directory does not exist\n";
+
+    # Try to open the file, because Locale::PO doesn't check :-/
+    open(INPUT, "<$str_file") || die "$str_file: $!\n";
+    close INPUT;
+
+    # creates the new tmpl file using the new translation
+    for my $input (@in_files) {
+#                die "Assertion failed"
+#                        unless substr($input, 0, length($in_dir) + 1) eq "$in_dir/";
+#                 print "$input / $type\n";
+		if (!defined $type || $input =~ /\.(?:$type)$/) {
+			my $h = TmplTokenizer->new( $input );
+			$h->set_allow_cformat( 1 );
+			VerboseWarnings::set_input_file_name $input;
+		
+			my $target = $out_dir . substr($input, length($in_dir));
+			my $targetdir = $` if $target =~ /[^\/]+$/s;
+			mkdir_recursive($targetdir) unless -d $targetdir;
+			print STDERR "Creating $target...\n" unless $quiet;
+			open( OUTPUT, ">$target" ) || die "$target: $!\n";
+			text_replace( $h, *OUTPUT );
+			close OUTPUT;
+		} else {
+		# just copying the file
+			my $target = $out_dir . substr($input, length($in_dir));
+			my $targetdir = $` if $target =~ /[^\/]+$/s;
+			mkdir_recursive($targetdir) unless -d $targetdir;
+			system("cp -f $input $target");
+			print STDERR "Copying $input...\n" unless $quiet;
+		}
+	}
+
+} else {
+    usage_error('Unknown action specified.');
+}
+
+if ($st == 0) {
+    printf "The %s seems to be successful.\n", $action unless $quiet;
+} else {
+    printf "%s FAILED.\n", "\u$action" unless $quiet;
+}
+exit 0;
+
+###############################################################################
+
+=head1 SYNOPSIS
+
+./tmpl_process3.pl [ I<tmpl_process.pl options> ]
+
+=head1 DESCRIPTION
+
+This is an alternative version of the tmpl_process.pl script,
+using standard gettext-style PO files.  While there still might
+be changes made to the way it extracts strings, at this moment
+it should be stable enough for general use; it is already being
+used for the Chinese and Polish translations.
+
+Currently, the create, update, and install actions have all been
+reimplemented and seem to work.
+
+=head2 Features
+
+=over
+
+=item -
+
+Translation files in standard Uniforum PO format.
+All standard tools including all gettext tools,
+plus PO file editors like kbabel(1) etc.
+can be used.
+
+=item -
+
+Minor changes in whitespace in source templates
+do not generally require strings to be re-translated.
+
+=item -
+
+Able to handle <TMPL_VAR> variables in the templates;
+<TMPL_VAR> variables are usually extracted in proper context,
+represented by a short %s placeholder.
+
+=item -
+
+Able to handle text input and radio button INPUT elements
+in the templates; these INPUT elements are also usually
+extracted in proper context,
+represented by a short %S or %p placeholder.
+
+=item -
+
+Automatic comments in the generated PO files to provide
+even more context (line numbers, and the names and types
+of the variables).
+
+=item -
+
+The %I<n>$s (or %I<n>$p, etc.) notation can be used
+for change the ordering of the variables,
+if such a reordering is required for correct translation.
+
+=item -
+
+If a particular <TMPL_VAR> should not appear in the
+translation, it can be suppressed with the %0.0s notation.
+
+=item -
+
+Using the PO format also means translators can add their
+own comments in the translation files, if necessary.
+
+=item -
+
+Create, update, and install actions are all based on the
+same scanner module. This ensures that update and install
+have the same idea of what is a translatable string;
+attribute names in tags, for example, will not be
+accidentally translated.
+
+=back
+
+=head1 NOTES
+
+Anchors are represented by an <AI<n>> notation.
+The meaning of this non-standard notation might not be obvious.
+
+The create action calls xgettext.pl to do the actual work;
+the update action calls xgettext.pl and msgmerge(1) to do the
+actual work.
+
+=head1 BUGS
+
+xgettext.pl must be present in the current directory; the
+msgmerge(1) command must also be present in the search path.
+The script currently does not check carefully whether these
+dependent commands are present.
+
+Locale::PO(3) has a lot of bugs. It can neither parse nor
+generate GNU PO files properly; a couple of workarounds have
+been written in TmplTokenizer and more is likely to be needed
+(e.g., to get rid of the "Strange line" warning for #~).
+
+This script may not work in Windows.
+
+There are probably some other bugs too, since this has not been
+tested very much.
+
+=head1 SEE ALSO
+
+xgettext.pl,
+TmplTokenizer.pm,
+msgmerge(1),
+Locale::PO(3),
+translator_doc.txt
+
+http://www.saas.nsw.edu.au/koha_wiki/index.php?page=DifficultTerms
+
+=cut
diff --git a/l10n/xgettext.pl b/l10n/xgettext.pl
new file mode 100755
index 0000000..b793867
--- /dev/null
+++ b/l10n/xgettext.pl
@@ -0,0 +1,469 @@
+#!/usr/bin/perl
+
+=head1 NAME
+
+xgettext.pl - xgettext(1)-like interface for .tmpl strings extraction
+
+=cut
+
+use strict;
+use Getopt::Long;
+use POSIX;
+use Locale::PO;
+use TmplTokenizer;
+use VerboseWarnings;
+
+use vars qw( $convert_from );
+use vars qw( $files_from $directory $output $sort );
+use vars qw( $extract_all_p );
+use vars qw( $pedantic_p );
+use vars qw( %text %translation );
+use vars qw( $charset_in $charset_out );
+use vars qw( $disable_fuzzy_p );
+use vars qw( $verbose_p );
+use vars qw( $po_mode_p );
+
+###############################################################################
+
+sub string_negligible_p ($) {
+    my($t) = @_;				# a string
+    # Don't emit pure whitespace, pure numbers, pure punctuation,
+    # single letters, or TMPL_VAR's.
+    # Punctuation should arguably be translated. But without context
+    # they are untranslatable. Note that $t is a string, not a token object.
+    return !$extract_all_p && (
+    	       TmplTokenizer::blank_p($t)	# blank or TMPL_VAR
+	    || $t =~ /^\d+$/			# purely digits
+	    || $t =~ /^[-\+\.,:;!\?'"%\(\)\[\]\|]+$/ # punctuation w/o context
+	    || $t =~ /^[A-Za-z]$/		# single letters
+	)
+}
+
+sub token_negligible_p( $ ) {
+    my($x) = @_;
+    my $t = $x->type;
+    return !$extract_all_p && (
+	    $t == TmplTokenType::TEXT? string_negligible_p( $x->string ):
+	    $t == TmplTokenType::DIRECTIVE? 1:
+	    $t == TmplTokenType::TEXT_PARAMETRIZED
+		&& join( '', map { my $t = $_->type;
+			$t == TmplTokenType::DIRECTIVE?
+				'1': $t == TmplTokenType::TAG?
+					'': token_negligible_p( $_ )?
+					'': '1' } @{$x->children} ) eq '' );
+}
+
+###############################################################################
+
+sub remember ($$) {
+    my($token, $string) = @_;
+    # If we determine that the string is negligible, don't bother to remember
+    unless (string_negligible_p( $string ) || token_negligible_p( $token )) {
+	my $key = TmplTokenizer::string_canon( $string );
+	$text{$key} = [] unless defined $text{$key};
+	push @{$text{$key}}, $token;
+    }
+}
+
+###############################################################################
+
+sub string_list () {
+    my @t = keys %text;
+    # The real gettext tools seems to sort case sensitively; I don't know why
+    @t = sort { $a cmp $b } @t if $sort eq 's';
+    @t = sort {
+	    my @aa = sort { $a->pathname cmp $b->pathname
+		    || $a->line_number <=> $b->line_number } @{$text{$a}};
+	    my @bb = sort { $a->pathname cmp $b->pathname
+		    || $a->line_number <=> $b->line_number } @{$text{$b}};
+	    $aa[0]->pathname cmp $bb[0]->pathname
+		    || $aa[0]->line_number <=> $bb[0]->line_number;
+	} @t if $sort eq 'F';
+    return @t;
+}
+
+###############################################################################
+
+sub text_extract (*) {
+    my($h) = @_;
+    for (;;) {
+	my $s = TmplTokenizer::next_token $h;
+    last unless defined $s;
+	my($kind, $t, $attr) = ($s->type, $s->string, $s->attributes);
+	if ($kind eq TmplTokenType::TEXT) {
+	    remember( $s, $t ) if $t =~ /\S/s;
+	} elsif ($kind eq TmplTokenType::TEXT_PARAMETRIZED) {
+	    remember( $s, $s->form ) if $s->form =~ /\S/s;
+	} elsif ($kind eq TmplTokenType::TAG && %$attr) {
+	    # value [tag=input], meta
+	    my $tag = lc($1) if $t =~ /^<(\S+)/s;
+	    for my $a ('alt', 'content', 'title', 'value') {
+		if ($attr->{$a}) {
+		    next if $a eq 'content' && $tag ne 'meta';
+		    next if $a eq 'value' && ($tag ne 'input'
+			|| (ref $attr->{'type'} && $attr->{'type'}->[1] =~ /^(?:hidden|radio)$/)); # FIXME
+		    my($key, $val, $val_orig, $order) = @{$attr->{$a}}; #FIXME
+		    $val = TmplTokenizer::trim $val;
+		    remember( $s, $val ) if $val =~ /\S/s;
+		}
+	    }
+	} elsif ($s->has_js_data) {
+	    for my $t (@{$s->js_data}) {
+		remember( $s, $t->[3] ) if $t->[0]; # FIXME
+	    }
+	}
+    }
+}
+
+###############################################################################
+
+sub generate_strings_list () {
+    # Emit all extracted strings.
+    for my $t (string_list) {
+	printf OUTPUT "%s\n", $t;
+    }
+}
+
+###############################################################################
+
+sub generate_po_file () {
+    # We don't emit the Plural-Forms header; it's meaningless for us
+    my $pot_charset = (defined $charset_out? $charset_out: 'CHARSET');
+    $pot_charset = TmplTokenizer::charset_canon $pot_charset;
+    # Time stamps aren't exactly right semantically. I don't know how to fix it.
+    my $time = POSIX::strftime('%Y-%m-%d %H:%M%z', localtime(time));
+    my $time_pot = $time;
+    my $time_po  = $po_mode_p? $time: 'YEAR-MO-DA HO:MI+ZONE';
+    print OUTPUT <<EOF;
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL\@ADDRESS>, YEAR.
+#
+EOF
+    print OUTPUT <<EOF unless $disable_fuzzy_p;
+#, fuzzy
+EOF
+    print OUTPUT <<EOF;
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\\n"
+"POT-Creation-Date: $time_pot\\n"
+"PO-Revision-Date: $time_po\\n"
+"Last-Translator: FULL NAME <EMAIL\@ADDRESS>\\n"
+"Language-Team: LANGUAGE <LL\@li.org>\\n"
+"MIME-Version: 1.0\\n"
+"Content-Type: text/plain; charset=$pot_charset\\n"
+"Content-Transfer-Encoding: 8bit\\n"
+
+EOF
+    my $directory_re = quotemeta("$directory/");
+    for my $t (string_list) {
+	if ($text{$t}->[0]->type == TmplTokenType::TEXT_PARAMETRIZED) {
+	    my($token, $n) = ($text{$t}->[0], 0);
+	    printf OUTPUT "#. For the first occurrence,\n"
+		    if @{$text{$t}} > 1 && $token->parameters_and_fields > 0;
+	    for my $param ($token->parameters_and_fields) {
+		$n += 1;
+		my $type = $param->type;
+		my $subtype = ($type == TmplTokenType::TAG
+			&& $param->string =~ /^<input\b/is?
+				$param->attributes->{'type'}->[1]: undef);
+		my $fmt = TmplTokenizer::_formalize( $param );
+		$fmt =~ s/^%/%$n\$/;
+		if ($type == TmplTokenType::DIRECTIVE) {
+		    $type = $param->string =~ /(TMPL_[A-Z]+)+/is? $1: 'ERROR';
+		    my $name = $param->string =~ /\bname=(["']?)([^\s"']+)\1/is?
+			    $2: undef;
+		    printf OUTPUT "#. %s: %s\n", $fmt,
+			"$type" . (defined $name? " name=$name": '');
+		} else {
+		    my $name = $param->attributes->{'name'};
+		    my $value = $param->attributes->{'value'}
+			    unless $subtype =~ /^(?:text)$/;
+		    printf OUTPUT "#. %s: %s\n", $fmt, "type=$subtype"
+			    . (defined $name?  " name=$name->[1]": '')
+			    . (defined $value? " value=$value->[1]": '');
+		}
+	    }
+	} elsif ($text{$t}->[0]->type == TmplTokenType::TAG) {
+	    my($token) = ($text{$t}->[0]);
+	    printf OUTPUT "#. For the first occurrence,\n"
+		    if @{$text{$t}} > 1 && $token->parameters_and_fields > 0;
+	    if ($token->string =~ /^<meta\b/is) {
+		my $type = $token->attributes->{'http-equiv'}->[1];
+		print OUTPUT "#. META http-equiv=$type\n" if defined $type;
+	    } elsif ($token->string =~ /^<([a-z0-9]+)/is) {
+		my $tag = uc($1);
+		my $type = (lc($tag) eq 'input'?
+			$token->attributes->{'type'}: undef);
+		my $name = $token->attributes->{'name'};
+		printf OUTPUT "#. %s\n", $tag
+		    . (defined $type? " type=$type->[1]": '')
+		    . (defined $name? " name=$name->[1]": '');
+	    }
+	} elsif ($text{$t}->[0]->has_js_data) {
+	    printf OUTPUT "#. For the first occurrence,\n" if @{$text{$t}} > 1;
+	    printf OUTPUT "#. SCRIPT\n";
+	}
+	my $cformat_p;
+	for my $token (@{$text{$t}}) {
+	    my $pathname = $token->pathname;
+	    $pathname =~ s/^$directory_re//os;
+	    printf OUTPUT "#: %s:%d\n", $pathname, $token->line_number
+		    if defined $pathname && defined $token->line_number;
+	    $cformat_p = 1 if $token->type == TmplTokenType::TEXT_PARAMETRIZED;
+	}
+	printf OUTPUT "#, c-format\n" if $cformat_p;
+	printf OUTPUT "msgid %s\n", TmplTokenizer::quote_po
+		TmplTokenizer::string_canon
+		TmplTokenizer::charset_convert $t, $charset_in, $charset_out;
+	printf OUTPUT "msgstr %s\n\n", (defined $translation{$t}?
+		TmplTokenizer::quote_po( $translation{$t} ): "\"\"");
+    }
+}
+
+###############################################################################
+
+sub convert_translation_file () {
+    open(INPUT, "<$convert_from") || die "$convert_from: $!\n";
+    VerboseWarnings::set_input_file_name $convert_from;
+    while (<INPUT>) {
+	chomp;
+	my($msgid, $msgstr) = split(/\t/);
+	die "$convert_from: $.: Malformed tmpl_process input (no tab)\n"
+		unless defined $msgstr;
+
+	# Fixup some of the bad strings
+	$msgid =~ s/^SELECTED>//;
+
+	# Create dummy token
+	my $token = TmplToken->new( $msgid, TmplTokenType::UNKNOWN, undef, undef );
+	remember( $token, $msgid );
+	$msgstr =~ s/^(?:LIMIT;|LIMITED;)//g; # unneeded for tmpl_process3
+	$translation{$msgid} = $msgstr unless $msgstr eq '*****';
+
+	if ($msgid  =~ /\bcharset=(["']?)([^;\s"']+)\1/s) {
+	    my $candidate = TmplTokenizer::charset_canon $2;
+	    die "Conflicting charsets in msgid: $candidate vs $charset_in\n"
+		    if defined $charset_in && $charset_in ne $candidate;
+	    $charset_in = $candidate;
+	}
+	if ($msgstr =~ /\bcharset=(["']?)([^;\s"']+)\1/s) {
+	    my $candidate = TmplTokenizer::charset_canon $2;
+	    die "Conflicting charsets in msgid: $candidate vs $charset_out\n"
+		    if defined $charset_out && $charset_out ne $candidate;
+	    $charset_out = $candidate;
+	}
+    }
+    # The following assumption is correct; that's what HTML::Template assumes
+    if (!defined $charset_in) {
+	$charset_in = $charset_out = TmplTokenizer::charset_canon 'iso8859-1';
+	warn "Warning: Can't determine original templates' charset, defaulting to $charset_in\n";
+    }
+}
+
+###############################################################################
+
+sub usage ($) {
+    my($exitcode) = @_;
+    my $h = $exitcode? *STDERR: *STDOUT;
+    print $h <<EOF;
+Usage: $0 [OPTIONS]
+Extract translatable strings from given HTML::Template input files.
+
+Input file location:
+  -f, --files-from=FILE          Get list of input files from FILE
+  -D, --directory=DIRECTORY      Add DIRECTORY to list for input files search
+
+Output file location:
+  -o, --output=FILE              Write output to specified file
+
+HTML::Template options:
+  -a, --extract-all              Extract all strings
+      --pedantic-warnings        Issue warnings even for detected problems
+                                 which are likely to be harmless
+
+Output details:
+  -s, --sort-output              generate sorted output
+  -F, --sort-by-file             sort output by file location
+  -v, --verbose                  explain what is being done
+
+Informative output:
+      --help                     Display this help and exit
+
+Try `perldoc $0' for perhaps more information.
+EOF
+    exit($exitcode);
+}
+
+###############################################################################
+
+sub usage_error (;$) {
+    print STDERR "$_[0]\n" if @_;
+    print STDERR "Try `$0 --help' for more information.\n";
+    exit(-1);
+}
+
+###############################################################################
+
+Getopt::Long::config qw( bundling no_auto_abbrev );
+GetOptions(
+    'a|extract-all'			=> \$extract_all_p,
+    'charset=s'	=> sub { $charset_in = $charset_out = $_[1] },	# INTERNAL
+    'convert-from=s'			=> \$convert_from,
+    'D|directory=s'			=> \$directory,
+    'disable-fuzzy'			=> \$disable_fuzzy_p,	# INTERNAL
+    'f|files-from=s'			=> \$files_from,
+    'I|input-charset=s'			=> \$charset_in,	# INTERNAL
+    'pedantic-warnings|pedantic'	=> sub { $pedantic_p = 1 },
+    'O|output-charset=s'		=> \$charset_out,	# INTERNAL
+    'output|o=s'			=> \$output,
+    'po-mode'				=> \$po_mode_p,		# INTERNAL
+    's|sort-output'			=> sub { $sort = 's' },
+    'F|sort-by-file'			=> sub { $sort = 'F' },
+    'v|verbose'				=> \$verbose_p,
+    'help'				=> sub { usage(0) },
+) || usage_error;
+
+VerboseWarnings::set_application_name $0;
+VerboseWarnings::set_pedantic_mode $pedantic_p;
+
+usage_error('Missing mandatory option -f')
+	unless defined $files_from || defined $convert_from;
+$directory = '.' unless defined $directory;
+
+usage_error('You cannot specify both --convert-from and --files-from')
+	if defined $convert_from && defined $files_from;
+
+if (defined $output && $output ne '-') {
+    print STDERR "$0: Opening output file \"$output\"\n" if $verbose_p;
+    open(OUTPUT, ">$output") || die "$output: $!\n";
+} else {
+    print STDERR "$0: Outputting to STDOUT...\n" if $verbose_p;
+    open(OUTPUT, ">&STDOUT");
+}
+
+if (defined $files_from) {
+    print STDERR "$0: Opening input file list \"$files_from\"\n" if $verbose_p;
+    open(INPUT, "<$files_from") || die "$files_from: $!\n";
+    while (<INPUT>) {
+	chomp;
+	my $input = /^\//? $_: "$directory/$_";
+	my $h = TmplTokenizer->new( $input );
+	$h->set_allow_cformat( 1 );
+	VerboseWarnings::set_input_file_name $input;
+	print STDERR "$0: Processing file \"$input\"\n" if $verbose_p;
+	text_extract( $h );
+    }
+    close INPUT;
+} else {
+    print STDERR "$0: Converting \"$convert_from\"\n" if $verbose_p;
+    convert_translation_file;
+}
+generate_po_file;
+
+warn "This input will not work with Mozilla standards-compliant mode\n", undef
+	if TmplTokenizer::syntaxerror_p;
+
+
+exit(-1) if TmplTokenizer::fatal_p;
+
+###############################################################################
+
+=head1 DESCRIPTION
+
+This is an experimental script based on the modularized
+text-extract2.pl script.  It has behaviour similar to
+xgettext(1), and generates gettext-compatible output files.
+
+A gettext-like format provides the following advantages:
+
+=over
+
+=item -
+
+Translation to non-English-like languages with different word
+order:  gettext's c-format strings can theoretically be
+emulated if we are able to do some analysis on the .tmpl input
+and treat <TMPL_VAR> in a way similar to %s.
+
+=item - 
+
+Context for the extracted strings:  the gettext format provides
+the filenames and line numbers where each string can be found.
+The translator can read the source file and see the context,
+in case the string by itself can mean several different things.
+
+=item - 
+
+Place for the translator to add comments about the translations.
+
+=item -
+
+Gettext-compatible tools, if any, might be usable if we adopt
+the gettext format.
+
+=back
+
+This script has already been in use for over a year and should
+be reasonable stable. Nevertheless, it is still somewhat
+experimental and there are still some issues.
+
+Please refer to the explanation in tmpl_process3 for further
+details.
+
+If you want to generate GNOME-style POTFILES.in files, such
+files (passed to -f) can be generated thus:
+
+	(cd ../.. && find koha-tmpl/opac-tmpl/default/en \
+		-name \*.inc -o -name \*.tmpl) > opac/POTFILES.in
+	(cd ../.. && find koha-tmpl/intranet-tmpl/default/en \
+		-name \*.inc -o -name \*.tmpl) > intranet/POTFILES.in
+
+This is, however, quite pointless, because the "create" and
+"update" actions have already been implemented in tmpl_process3.pl.
+
+=head2 Strings inside JavaScript
+
+In the SCRIPT elements, the script will attempt to scan for
+_("I<string literal>") patterns, and extract the I<string literal>
+as a translatable string.
+
+Note that the C-like _(...) notation is required.
+
+The JavaScript must actually define a _ function
+so that the code remains correct JavaScript.
+A suitable definition of such a function can be
+
+	function _(s) { return s } // dummy function for gettext
+
+=head1 SEE ALSO
+
+tmpl_process3.pl,
+xgettext(1),
+Locale::PO(3),
+translator_doc.txt
+
+=head1 BUGS
+
+There probably are some. Bugs related to scanning of <INPUT>
+tags seem to be especially likely to be present.
+
+Its diagnostics are probably too verbose.
+
+When a <TMPL_VAR> within a JavaScript-related attribute is
+detected, the script currently displays no warnings at all.
+It might be good to display some kind of warning.
+
+Its sort order (-s option) seems to be different than the real
+xgettext(1)'s sort option. This will result in translation
+strings inside the generated PO file spuriously moving about
+when tmpl_process3.pl calls msgmerge(1) to update the PO file.
+
+If a Javascript string has leading spaces, it will
+generate strings with spurious leading spaces,
+leading to failure to match the strings when actually generating
+translated files.
+
+=cut
diff --git a/po/templates.pot b/po/templates.pot
new file mode 100644
index 0000000..e318f2e
--- /dev/null
+++ b/po/templates.pot
@@ -0,0 +1,141 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2006-07-11 03:00+0300\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=CHARSET\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#. For the first occurrence,
+#. %1$s: TMPL_VAR
+#. %2$s: TMPL_VAR
+#: ../templates/editpage.tmpl:24 ../templates/misc.tmpl:16
+#: ../templates/recentchanges.tmpl:16
+#, c-format
+msgid "%s/ %s"
+msgstr ""
+
+#. For the first occurrence,
+#. %1$s: TMPL_VAR
+#: ../templates/inlinepage.tmpl:7 ../templates/inlinepagetitle.tmpl:3
+#, c-format
+msgid "(posted %s)"
+msgstr ""
+
+#. %1$s: TMPL_VAR name=PAGE>
+#: ../templates/page.tmpl:17
+#, c-format
+msgid "<a1>%s</a>/"
+msgstr ""
+
+#: ../templates/blogpost.tmpl:9
+msgid "Add a new post titled:"
+msgstr ""
+
+#: ../templates/editpage.tmpl:18
+msgid ""
+"Conflict markers have been inserted into the page content. Reconcile the "
+"confict and commit again to save your changes."
+msgstr ""
+
+#: ../templates/page.tmpl:30 ../templates/blogpost.tmpl:10
+msgid "Edit"
+msgstr ""
+
+#: ../templates/page.tmpl:36
+msgid "History"
+msgstr ""
+
+#. %1$s: TMPL_VAR name=MTIME>
+#: ../templates/page.tmpl:64
+#, c-format
+msgid "Last edited %s"
+msgstr ""
+
+#: ../templates/page.tmpl:54
+msgid "Links:"
+msgstr ""
+
+#: ../templates/editpage.tmpl:37
+msgid "Optional comment about this change:"
+msgstr ""
+
+#. %1$s: TMPL_VAR
+#: ../templates/editpage.tmpl:30
+#, c-format
+msgid "Page location: %s"
+msgstr ""
+
+#: ../templates/editpage.tmpl:46
+msgid "Page preview:"
+msgstr ""
+
+#: ../templates/page.tmpl:39
+msgid "Preferences"
+msgstr ""
+
+#: ../templates/blogpost.tmpl:4 ../templates/rsslink.tmpl:3
+msgid "RSS"
+msgstr ""
+
+#: ../templates/page.tmpl:33
+msgid "RecentChanges"
+msgstr ""
+
+#. %1$s: TMPL_VAR
+#. %2$s: TMPL_VAR
+#. %3$s: TMPL_VAR
+#. %4$s: TMPL_VAR
+#. %5$s: TMPL_VAR
+#: ../templates/passwordmail.tmpl:1
+#, c-format
+msgid ""
+"Someone[1], possibly you, requested that you be emailed the password for "
+"user %s on %s[2]. The password is: %s -- ikiwiki [1] The user requesting the "
+"password was at IP address %s [2] Located at %s"
+msgstr ""
+
+#. %1$s: TMPL_VAR
+#. %2$s: TMPL_VAR
+#. %3$s: TMPL_VAR
+#. %4$s: TMPL_VAR
+#: ../templates/notifymail.tmpl:1
+#, c-format
+msgid "The following change was made to %s by %s: %s %s"
+msgstr ""
+
+#: ../templates/editpage.tmpl:15
+msgid "Your changes confict with other changes made to the page."
+msgstr ""
+
+#: ../templates/recentchanges.tmpl:27
+msgid "changes"
+msgstr ""
+
+#. IMG
+#: ../templates/recentchanges.tmpl:40
+msgid "diff"
+msgstr ""
+
+#. META http-equiv=Content-Type
+#: ../templates/page.tmpl:5 ../templates/editpage.tmpl:8
+#: ../templates/misc.tmpl:8 ../templates/recentchanges.tmpl:8
+msgid "text/html; charset=utf-8"
+msgstr ""
+
+#: ../templates/recentchanges.tmpl:26
+msgid "time"
+msgstr ""
+
+#: ../templates/recentchanges.tmpl:25
+msgid "user"
+msgstr ""
diff --git a/po/tr.po b/po/tr.po
new file mode 100644
index 0000000..1547133
--- /dev/null
+++ b/po/tr.po
@@ -0,0 +1,148 @@
+# Turkish translation of ikiwiki templates.
+# This file is distributed under the same license as the ikiwiki package.
+# Recai Oktaş <roktas@debian.org>, 2006.
+msgid ""
+msgstr ""
+"Project-Id-Version: ikiwiki\n"
+"POT-Creation-Date: 2006-07-11 03:00+0300\n"
+"PO-Revision-Date: 2006-07-11 03:14+0300\n"
+"Last-Translator:Recai Oktaş <roktas@debian.org>\n"
+"Language-Team: Debian L10N Turkish <debian-l10n-turkish@lists.debian.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+
+#. For the first occurrence,
+#. %1$s: TMPL_VAR
+#. %2$s: TMPL_VAR
+#: ../templates/editpage.tmpl:24 ../templates/misc.tmpl:16
+#: ../templates/recentchanges.tmpl:16
+#, c-format
+msgid "%s/ %s"
+msgstr "%s/ %s"
+
+#. For the first occurrence,
+#. %1$s: TMPL_VAR
+#: ../templates/inlinepage.tmpl:7 ../templates/inlinepagetitle.tmpl:3
+#, c-format
+msgid "(posted %s)"
+msgstr "(gönderi tarihi %s)"
+
+#. %1$s: TMPL_VAR name=PAGE>
+#: ../templates/page.tmpl:17
+#, c-format
+msgid "<a1>%s</a>/"
+msgstr "<a1>%s</a>/"
+
+#: ../templates/blogpost.tmpl:9
+msgid "Add a new post titled:"
+msgstr "Eklenecek yeni iletinin başlığı:"
+
+#: ../templates/editpage.tmpl:18
+msgid ""
+"Conflict markers have been inserted into the page content. Reconcile the "
+"confict and commit again to save your changes."
+msgstr ""
+"İçerikteki çakışmalar \"çakışma işaretleri\" kullanılarak işaretlendi. "
+"Çakışmayı giderin ve yaptığınız değişiklikleri kaydetmek için tekrar "
+"gönderin."
+
+#: ../templates/page.tmpl:30 ../templates/blogpost.tmpl:10
+msgid "Edit"
+msgstr "Düzenle"
+
+#: ../templates/page.tmpl:36
+msgid "History"
+msgstr "Geçmiş"
+
+#. %1$s: TMPL_VAR name=MTIME>
+#: ../templates/page.tmpl:64
+#, c-format
+msgid "Last edited %s"
+msgstr "Son düzenleme %s"
+
+#: ../templates/page.tmpl:54
+msgid "Links:"
+msgstr "Bağlar:"
+
+#: ../templates/editpage.tmpl:37
+msgid "Optional comment about this change:"
+msgstr "Bu değişiklik için açıklama (isteğe bağlı):"
+
+#. %1$s: TMPL_VAR
+#: ../templates/editpage.tmpl:30
+#, c-format
+msgid "Page location: %s"
+msgstr "Sayfa yeri: %s"
+
+#: ../templates/editpage.tmpl:46
+msgid "Page preview:"
+msgstr "Sayfa önizleme:"
+
+#: ../templates/page.tmpl:39
+msgid "Preferences"
+msgstr "Ayarlar"
+
+#: ../templates/blogpost.tmpl:4 ../templates/rsslink.tmpl:3
+msgid "RSS"
+msgstr "RSS"
+
+#: ../templates/page.tmpl:33
+msgid "RecentChanges"
+msgstr "Değişiklikler"
+
+#. %1$s: TMPL_VAR
+#. %2$s: TMPL_VAR
+#. %3$s: TMPL_VAR
+#. %4$s: TMPL_VAR
+#. %5$s: TMPL_VAR
+#: ../templates/passwordmail.tmpl:1
+#, c-format
+msgid ""
+"Someone[1], possibly you, requested that you be emailed the password for "
+"user %s on %s[2]. The password is: %s -- ikiwiki [1] The user requesting the "
+"password was at IP address %s [2] Located at %s"
+msgstr ""
+"Birisi[1], ki muhtemelen bu sizsiniz, %2$s[2] üzerindeki %1$s kullanıcısına "
+"ait parolanın epostalanması isteğinde bulundu. Parola: %3$s -- ikiwiki "
+"[1] Parolayı isteyen kullanıcının ait IP adresi: %4$s"
+"[2] %s"
+
+#. %1$s: TMPL_VAR
+#. %2$s: TMPL_VAR
+#. %3$s: TMPL_VAR
+#. %4$s: TMPL_VAR
+#: ../templates/notifymail.tmpl:1
+#, c-format
+msgid "The following change was made to %s by %s: %s %s"
+msgstr "%1$s üzerinde %2$s tarafından şu değişiklik yapıldı: %s %s"
+
+#: ../templates/editpage.tmpl:15
+msgid "Your changes confict with other changes made to the page."
+msgstr ""
+"Yaptığınız değişiklikler bu sayfada başkaları tarafından yapılan "
+"değişikliklerle çakışıyor."
+
+#: ../templates/recentchanges.tmpl:27
+msgid "changes"
+msgstr "değişiklikler"
+
+#. IMG
+#: ../templates/recentchanges.tmpl:40
+msgid "diff"
+msgstr "fark"
+
+#. META http-equiv=Content-Type
+#: ../templates/page.tmpl:5 ../templates/editpage.tmpl:8
+#: ../templates/misc.tmpl:8 ../templates/recentchanges.tmpl:8
+msgid "text/html; charset=utf-8"
+msgstr "text/html; charset=utf-8"
+
+#: ../templates/recentchanges.tmpl:26
+msgid "time"
+msgstr "tarih"
+
+#: ../templates/recentchanges.tmpl:25
+msgid "user"
+msgstr "kullanıcı"