#! /usr/bin/env perl

### TODO: other copyrights, license?
# Copyright (c) 2004 Richard Evans <rich@ridas.com>

sub usage
{
  warn <<"EOF";

extractrc [flags] filenames

This script extracts messages from designer (.ui) and XMLGUI (.rc) files and
writes on standard output (usually redirected to rc.cpp) the equivalent
i18n() calls so that xgettext can parse them.

--tag=name        : Also extract the tag name(s). Repeat the flag to specify 
                    multiple names: --tag=tag_one --tag=tag_two

--tag-group=group : Use a group of tags - uses 'default' if omitted.
                    Valid groups are: @{[TAG_GROUPS()]}

--context=name    : Give i18n calls a context name: i18nc("name", ...)
--lines           : Include source line numbers in comments (deprecated, it is switched on by default now)
--cstart=chars    : Start of to-EOL style comments in output, defaults to //
--help|?          : Display this summary

EOF

  exit;
}

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

use strict;
use warnings;
use Getopt::Long;
use Data::Dumper;

use constant TAG_GROUP => 
{
  default => "[tT][eE][xX][tT]|title|string|whatsthis|tooltip|label",
  koffice => "Example|GroupName|Text|Comment|Syntax|TypeName",
  none    => "",
};

use constant TAG_GROUPS => join ", ", map "'$_'", sort keys %{&TAG_GROUP};

# Specification to extract nice element-context for strings.
use constant ECTX_SPEC =>
{
  # Data structure: extension => {tag => [ctxlevel, [attribute, ...]], ...}
  # Order of attributes determines their order in the extracted comment.
  "ui" => {
    "widget" => [10, ["class", "name"]],
    "item" => [15, []],
    "property" => [20, ["name"]],
    "attribute" => [20, ["name"]],
  },
  "rc" => {
    "Menu" => [10, ["name"]],
    "ToolBar" => [10, ["name"]],
  },
  "kcfg" => {
    "group" => [10, ["name"]],
    "entry" => [20, ["name"]],
    "whatsthis" => [30, []],
    "tooltip" => [30, []],
    "label" => [30, []],
  },
};

# Add attribute lists as hashes, for membership checks.
for my $ext ( keys %{&ECTX_SPEC} ) {
  for my $tag ( keys %{ECTX_SPEC->{$ext}} ) {
    my $arr = ECTX_SPEC->{$ext}{$tag}[1];
    ECTX_SPEC->{$ext}{$tag}[2] = {map {$_ => 1} @{$arr}};
  }
}

###########################################################################################
# Add options here as necessary - perldoc Getopt::Long for details on GetOptions

GetOptions ( "tag=s"       => \my @opt_extra_tags,
             "tag-group=s" => \my $opt_tag_group,
             "context=s"   => \my $opt_context,       # I18N context
             "lines"       => \my $opt_lines,
             "cstart=s"    => \my $opt_cstart,
             "help|?"      => \&usage );

unless( @ARGV )
{
  warn "No filename specified";
  exit;
}

$opt_tag_group ||= "default";

die "Unknown tag group: '$opt_tag_group', should be one of " . TAG_GROUPS
    unless exists TAG_GROUP->{$opt_tag_group};

my $tags = TAG_GROUP->{$opt_tag_group};
my $extra_tags  = join "", map "|" . quotemeta, @opt_extra_tags;
my $text_string = qr/($tags$extra_tags)( [^>]*)?>/;    # Precompile regexp
my $cstart = $opt_cstart || "//";
my $ectx_known_exts = join "|", keys %{&ECTX_SPEC};

###########################################################################################
#  Escape characters in string exactly like uic does.
sub escape_like_uic ($) {
    my $text = shift;

    $text =~ s/&lt;/</g;
    $text =~ s/&gt;/>/g;
    $text =~ s/&amp;/&/g;
    $text =~ s/&quot;/"/g;

    $text =~ s/\\/\\\\/g; # escape \
    $text =~ s/\"/\\\"/g; # escape "
    $text =~ s/\r//g; # remove CR (Carriage Return)
    $text =~ s/\n/\\n\"\n\"/g; # escape LF (Line Feed). uic also change the code line at a LF, we do not do that.

    return $text;
}

###########################################################################################
# Program start proper - NB $. is the current line number

for my $file_name ( @ARGV )
{
  my $fh;

  unless ( open $fh, "<", $file_name )
  {
    # warn "Failed to open: '$file_name': $!";
    next;
  }

  # Ready element-context extraction.
  my $ectx_ext;
  my $ectx_string;
  if ( $file_name =~ /\.($ectx_known_exts)$/ ) {
    $ectx_ext = $1;
    my $ectx_tag_gr = join "|", keys %{ECTX_SPEC->{$ectx_ext}};
    $ectx_string = qr/($ectx_tag_gr)( [^>]*)?>/; # precompile regexp
  }

  my $string          = "";
  my $in_text         = 0;
  my $start_line_no   = 0;
  my $in_skipped_prop = 0;
  my $tag = "";
  my $attr = "";
  my $context = "";

  # Element-context data: [[level, tag, [[attribute, value], ...]], ...]
  # such that subarrays are ordered increasing by level.
  my @ectx = ();

  while ( <$fh> )
  {
     last if $. == 1 and $_ !~ /^(?:<!DOCTYPE|<\?xml|<!--|<ui version=)/;

     chomp;

     $string .= "\n" . $_;
     
     # 'database', 'associations', 'populationText' and 'styleSheet' properties contain strings that shouldn't be translated

     if ( $in_skipped_prop == 0 and $string =~ /<property name=\"(?:database|associations|populationText|styleSheet)\"/ )
     {
       $in_skipped_prop = 1;
     }
     elsif ( $in_skipped_prop and $string =~ /<\/property/ )
     {
       $string          = "";
       $in_skipped_prop = 0;
     }

     $context = $opt_context unless $in_text;

     unless ( $in_skipped_prop or $in_text )
     {
       # Check if this line contains context-worthy element.
       if (    $ectx_ext
           and ( ($tag, $attr) = $string =~ /<$ectx_string/ ) # no /o here
           and exists ECTX_SPEC->{$ectx_ext}{$tag} )
       {
         my @atts;
         for my $ectx_att ( @{ECTX_SPEC->{$ectx_ext}{$tag}[1]} )
         {
           if ( $attr and $attr =~ /\b$ectx_att\s*=\s*(["'])([^"']*?)\1/ )
           {
             my $aval = $2;
             push @atts, [$ectx_att, $aval];
           }
         }
         # Kill all tags in element-context with level higer or equal to this,
         # and add it to the end.
         my $clevel = ECTX_SPEC->{$ectx_ext}{$tag}[0];
         for ( my $i = 0; $i < @ectx; ++$i )
         {
           if ( $clevel <= $ectx[$i][0] )
           {
             @ectx = @ectx[0 .. ($i - 1)];
             last;
           }
         }
         push @ectx, [$clevel, $tag, [@atts]];
       }

       if ( ($tag, $attr) = $string =~ /<$text_string/o )
       {
         my ($attr_comment) = $attr =~ /\w*comment=\"([^\"]*)\"/ if $attr;
         $context = $attr_comment if $attr_comment;
         my ($attr_context) = $attr =~ /\w*context=\"([^\"]*)\"/ if $attr;
         $context = $attr_context if $attr_context;
         # It is unlikely that both attributes 'context' and 'comment'
         # will be present, but if so happens, 'context' has priority.

         $string        =~ s/^.*<$text_string//so;
         $in_text       =  1;
         $start_line_no =  $.;
       }
       else
       {
         $string = "";
       }
     }

     next unless $in_text;
     next unless $string =~ /<\/$text_string/o;

     my $text = $string;
     $text =~ s/<\/$text_string.*$//o;

     if ( $text cmp "" )
     {
       if ( not $context or $context ne "KDE::DoNotExtract" )
       {
         (my $norm_fname = $file_name) =~ s/^\.\///;
         print "$cstart i18n: file: $norm_fname:$.\n";
         if ( @ectx ) {
           # Format element-context.
           my @tag_gr;
           for my $tgr (reverse @ectx)
           {
             my @attr_gr;
             for my $agr ( @{$tgr->[2]} )
             {
               #push @attr_gr, "$agr->[0]=$agr->[1]";
               push @attr_gr, "$agr->[1]"; # no real nead for attribute name
             }
             my $attr = join(", ", @attr_gr);
             push @tag_gr, "$tgr->[1] ($attr)" if $attr;
             push @tag_gr, "$tgr->[1]" if not $attr;
           }
           my $ectx_str = join ", ", @tag_gr;
           print "$cstart i18n: ectx: $ectx_str\n";
         }
         print "$cstart xgettext: no-c-format\n" if $text =~ /%/o;
         if ( $context )
         {
           $context = escape_like_uic($context);
           $text = escape_like_uic($text);
           print qq|i18nc("$context","$text");\n|;
         }
         else
         {
           $text = escape_like_uic($text);
           print  qq|i18n("$text");\n|;
         }
       }
       else
       {
         print "$cstart Manually excluded message at $file_name line $.\n";
       }
     }
     else
     {
       print "$cstart Skipped empty message at $file_name line $.\n";
     }

     $string  =~ s/^.*<\/$text_string//o;
     $in_text =  0;

     # Text can be multiline in .ui files (possibly), but we warn about it in XMLGUI .rc files.

     warn "there is <text> floating in: '$file_name'" if $. != $start_line_no and $file_name =~ /\.rc$/i;
  }

  close $fh or warn "Failed to close: '$file_name': $!";

  die "parsing error in $file_name" if $in_text;
}

