gettext 1.0.0-mswin32

data/lib/gettext/locale_win32.rb

@@ -0,0 +1,35 @@
+=begin
+  locale_win32.rb - Locale module for win32.
+
+  Copyright (C) 2002,2003  Masao Mutoh <mutoh@highway.ne.jp>
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: locale_win32.rb,v 1.2 2005/08/20 17:05:34 mutoh Exp $
+=end
+
+require 'gettext/locale_table_win32'
+
+module Locale
+  def __get
+    pri_id, sub_id = __locale_id
+    lang = LocaleTable.assoc(pri_id)
+    if lang.size == 3
+      lang = lang[2].assoc(sub_id)
+    end
+    lang ? lang[1] : nil
+  end
+
+  unless defined? CTYPE
+    CTYPE = 0
+    NUMERIC = 1
+    TIME = 2
+    COLLATE = 3
+    MONETARY = 4
+    MESSAGES = 5
+    ALL = 6
+  end
+  module_function :__get
+end
+

data/lib/gettext/mo.rb

@@ -0,0 +1,262 @@
+=begin
+    mo.rb - A simple class for operating GNU MO file.
+
+    Copyright (C) 2003-2005  Masao Mutoh
+    Copyright (C) 2002  Masahiro Sakai, Masao Mutoh
+    Copyright (C) 2001  Masahiro Sakai
+
+        Masahiro Sakai                  <s01397ms@sfc.keio.ac.jp>
+        Masao Mutoh                     <mutoh@highway.ne.jp>
+
+    You can redistribute this file and/or modify it under the same term
+    of Ruby.  License of Ruby is included with Ruby distribution in
+    the file "README".
+
+    $Id: mo.rb,v 1.1.1.1 2005/08/13 02:38:09 mutoh Exp $
+=end
+
+require 'gettext/iconv'
+
+class MOFile < Hash
+  class InvalidFormat < RuntimeError; end;
+
+  Header = Struct.new(:magic,
+                      :revision,
+                      :nstrings,
+                      :orig_table_offset,
+                      :translated_table_offset,
+                      :hash_table_size,
+                      :hash_table_offset)
+
+  MAGIC_BIG_ENDIAN    = "\x95\x04\x12\xde"
+  MAGIC_LITTLE_ENDIAN = "\xde\x12\x04\x95"
+
+  def self.open(arg = nil, output_charset = nil)
+    result = self.new(output_charset)
+    case arg
+    when String
+      result.load_from_file(arg)
+    when IO
+      result.load_from_stream(arg)
+    end
+    result
+  end
+
+  def initialize(output_charset = nil)
+    @little_endian = true
+    @output_charset = output_charset
+    super()
+  end
+
+  def load_from_stream(io)
+    magic = io.read(4)
+    case magic
+    when MAGIC_BIG_ENDIAN
+      @little_endian = false
+    when MAGIC_LITTLE_ENDIAN
+      @little_endian = true
+    else
+      raise InvalidFormat.new(sprintf("Unknown signature %s", magic.dump))
+    end
+
+    header = Header.new(magic, *(io.read(4 * 6).unpack(@little_endian ? 'V6' : 'N6')))
+    raise InvalidFormat.new(sprintf("file format revision %d isn't supported", header.revision)) if header.revision > 0
+
+    io.pos = header.orig_table_offset
+    orig_table_data = io.read((4 * 2) * header.nstrings).unpack(@little_endian ? 'V*' : 'N*')
+
+    io.pos = header.translated_table_offset
+    trans_table_data = io.read((4 * 2) * header.nstrings).unpack(@little_endian ? 'V*' : 'N*')
+
+    original_strings = Array.new(header.nstrings)
+    for i in 0...header.nstrings
+      io.pos = orig_table_data[i * 2 + 1]
+      original_strings[i] = io.read(orig_table_data[i * 2 + 0])
+    end
+
+    clear
+    for i in 0...header.nstrings
+      io.pos = trans_table_data[i * 2 + 1]
+      str = io.read(trans_table_data[i * 2 + 0])
+
+      if original_strings[i] == ""
+        if str
+          @charset = nil
+          @nplurals = nil
+          @plural = nil
+          str.each_line{|line|
+            if /^Content-Type:/i =~ line and /charset=((?:\w|-)+)/i =~ line
+              @charset = $1
+            elsif /^Plural-Forms:\s*nplurals\s*\=\s*(\d*);\s*plural\s*\=\s*([^;]*)\n?/ =~ line
+              @nplurals = $1
+              @plural = $2
+            end
+            break if @charset and @nplurals
+          }
+          @nplurals = "1" unless @nplurals
+          @plural = "0" unless @plural
+        end
+      else
+        if @output_charset
+          begin
+            str = Iconv.iconv(@output_charset, @charset, str).join if @charset
+          rescue Iconv::Failure
+            if $DEBUG
+              $stderr.print "@charset = ", @charset, "\n"
+              $stderr.print "@output_charset = ", @output_charset, "\n"
+              $stderr.print "msgid = ", original_strings[i], "\n"
+              $stderr.print "msgstr = ", str, "\n"
+            end
+          end
+        end
+      end
+      self[original_strings[i]] = str
+    end
+    self
+  end
+
+  # From gettext-0.12.1/gettext-tools/lib/hash.c
+  def prime?(candidate)
+    divn = 3
+    sq = divn * divn
+
+    while (sq < candidate && candidate % divn != 0)
+      divn += 1
+      sq += 4 * divn
+      divn += 1
+    end
+    candidate % divn != 0
+  end
+
+  # From gettext-0.12.1/gettext-tools/lib/hash.c
+  def next_prime(seed)
+    seed |= 1
+    while (! prime?(seed))
+      seed += 2
+    end
+    seed
+  end
+
+  # From gettext-0.12.1/gettext-runtime/intl/hash-string.h
+  # Defines the so called `hashpjw' function by P.J. Weinberger
+  # [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
+  # 1986, 1987 Bell Telephone Laboratories, Inc.] 
+  HASHWORDBITS = 32
+  def hash_string(str)
+    hval = 0
+    i = 0
+    str.each_byte do |b|
+      break if b == '\0'
+      hval <<= 4
+      hval += b.to_i
+      g = hval & (0xf << (HASHWORDBITS - 4))
+      if (g != 0)
+        hval ^= g >> (HASHWORDBITS - 8)
+        hval ^= g
+      end
+    end
+    hval
+  end
+
+  def save_to_stream(io)
+    #Save data as little endian format.
+    header_size = 4 * 7
+    table_size  = 4 * 2 * size
+
+    hash_table_size = next_prime((size * 4) / 3) 
+    hash_table_size = 3 if hash_table_size <= 2
+    header = Header.new(
+      MAGIC_LITTLE_ENDIAN,          # magic
+      0,                            # revision
+      size,                         # nstrings
+      header_size,                  # orig_table_offset
+      header_size + table_size,     # translated_table_offset
+      hash_table_size,              # hash_table_size
+      header_size + table_size * 2  # hash_table_offset
+    )
+    io.write(header.to_a.pack('a4V*'))
+
+    ary = to_a
+    ary.sort!{|a, b| a[0] <=> b[0]} # sort by original string
+
+    pos = header.hash_table_size * 4 + header.hash_table_offset
+
+    orig_table_data = Array.new()
+    ary.each{|item, _|
+      orig_table_data.push(item.size)
+      orig_table_data.push(pos)
+      pos += item.size + 1 # +1 is <NUL>
+    }
+    io.write(orig_table_data.pack('V*'))
+
+    trans_table_data = Array.new()
+    ary.each{|_, item|
+      trans_table_data.push(item.size)
+      trans_table_data.push(pos)
+      pos += item.size + 1 # +1 is <NUL>
+    }
+    io.write(trans_table_data.pack('V*'))
+
+    hash_tab = Array.new(hash_table_size)
+    j = 0
+    ary[0...size].each {|key, _|
+      hash_val = hash_string(key)
+      idx = hash_val % hash_table_size
+      if hash_tab[idx] != nil
+        incr = 1 + (hash_val % (hash_table_size - 2))
+        begin
+          if (idx >= hash_table_size - incr)
+            idx -= hash_table_size - incr
+          else
+            idx += incr
+          end
+        end until (hash_tab[idx] == nil)
+      end
+      hash_tab[idx] = j + 1
+      j += 1
+    }
+    hash_tab.collect!{|i| i ? i : 0}
+
+    io.write(hash_tab.pack('V*'))
+
+    ary.each{|item, _| io.write(item); io.write("\0") }
+    ary.each{|_, item| io.write(item); io.write("\0") }
+
+    self
+  end
+
+  def load_from_file(filename)
+    File.open(filename, 'rb'){|f| load_from_stream(f)}
+  end
+
+  def save_to_file(filename)
+    File.open(filename, 'wb'){|f| save_to_stream(f)}
+  end
+
+  attr_accessor :little_endian
+  attr_reader :charset, :nplurals, :plural
+end
+
+
+# Test
+
+if $0 == __FILE__
+  if (ARGV.include? "-h") or (ARGV.include? "--help")
+    STDERR.puts("mo.rb [filename.mo ...]")
+    exit
+  end
+
+  ARGV.each{ |item|
+    mo = MOFile.open(item)
+    puts "------------------------------------------------------------------"
+    puts "charset  = \"#{mo.charset}\""
+    puts "nplurals = \"#{mo.nplurals}\""
+    puts "plural   = \"#{mo.plural}\""
+    puts "------------------------------------------------------------------"
+    mo.each do |key, value|
+      puts "original message = \"#{key}\""
+      puts "translated message = \"#{value}\""
+      puts "--------------------------------------------------------------------"
+    end
+  }
+end

data/lib/gettext/parser/erb.rb

@@ -0,0 +1,34 @@
+=begin
+  parser/erb.rb - parser for ERB
+
+  Copyright (C) 2005  Masao Mutoh
+ 
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: erb.rb,v 1.2 2005/08/20 17:05:34 mutoh Exp $
+=end
+
+require 'erb'
+require 'gettext/parser/ruby.rb'
+
+module GetText
+  module ErbParser
+    module_function
+    def parse(file, targets = [])
+      erb = ERB.new(IO.readlines(file).join).src.split(/$/)
+      RubyParser.parse_lines(file, erb, targets)
+    end
+
+    def target?(file)
+      File.extname(file) == '.rhtml'
+    end
+  end
+end
+
+if __FILE__ == $0
+  # ex) ruby glade.rhtml foo.rhtml  bar.rhtml
+  ARGV.each do |file|
+    p GetText::ErbParser.parse(file)
+  end
+end

data/lib/gettext/parser/glade.rb

@@ -0,0 +1,98 @@
+=begin
+  parser/glade.rb - parser for Glade-2
+
+  Copyright (C) 2004,2005  Masao Mutoh
+ 
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: glade.rb,v 1.1.1.1 2005/08/13 02:38:09 mutoh Exp $
+=end
+
+require 'cgi'
+require 'gettext'
+
+module GetText
+  module GladeParser
+
+    TARGET1 = /<property.*translatable="yes">(.*)/
+    TARGET2 = /(.*)<\/property>/
+
+    module_function
+    def parse(file, targets = [])
+      lines = IO.readlines(file)
+      parse_lines(file, lines, targets)
+    end
+
+    #from ary of lines.
+    def parse_lines(file, lines, targets)
+      cnt = 0
+      target = false
+      line_no = 0
+      val = nil
+      
+      loop do 
+        line = lines.shift
+        break unless line
+        
+        cnt += 1
+        if TARGET1 =~ line
+          line_no = cnt
+          val = $1 + "\n"
+          target = true
+          if TARGET2 =~ $1
+            val = $1
+            add_target(val, file, line_no, targets)
+            val = nil
+            target = false
+          end
+        elsif target
+          if TARGET2 =~ line
+            val << $1
+            add_target(val, file, line_no, targets)
+            val = nil
+            target = false
+          else
+            val << line
+          end
+        end
+      end
+      targets
+    end
+
+    XML_RE = /<\?xml/ 
+    GLADE_RE = /glade-2.0.dtd/
+ 
+    def target?(file)
+      data = IO.readlines(file)
+      if XML_RE =~ data[0]
+	if GLADE_RE =~ data[1]
+	  return true
+	else
+	  raise _("%s is not glade-2.0 format.") % [file]
+	end
+      else
+	return false
+      end
+    end
+
+    def add_target(val, file, line_no, targets)
+      return unless val.size > 0
+      assoc_data = targets.assoc(val)
+      val = CGI.unescapeHTML(val)
+      if assoc_data 
+        targets[targets.index(assoc_data)] = assoc_data << "#{file}:#{line_no}"
+      else
+        targets << [val.gsub(/\n/, '\n'), "#{file}:#{line_no}"]
+      end
+      targets
+    end
+  end
+end
+
+if __FILE__ == $0
+  # ex) ruby glade.rb foo.glade  bar.glade
+  ARGV.each do |file|
+    p GetText::GladeParser.parse(file)
+  end
+end

data/lib/gettext/parser/ruby.rb

@@ -0,0 +1,211 @@
+#!/usr/bin/ruby
+=begin
+  parser/ruby.rb - parser for ruby script
+
+  Copyright (C) 2003-2005  Masao Mutoh
+  Copyright (C) 2001,2002  Yasushi Shoji, Masao Mutoh
+ 
+      Yasushi Shoji   <yashi@yashi.com>
+      Masao Mutoh     <mutoh@highway.ne.jp>
+ 
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: ruby.rb,v 1.1.1.1 2005/08/13 02:38:09 mutoh Exp $
+=end
+
+require 'irb/ruby-lex'
+require 'irb/ruby-token'
+require 'stringio'
+
+class RubyLexX < RubyLex
+  def initialize
+    super
+    @prompt = nil
+    @here_header = nil
+    @lex_state = nil
+  end
+
+  def token
+    tk = super
+    if $DEBUG
+      if tk.is_a? TkSTRING
+        $stderr.puts("#{tk}: #{tk.value}")
+      elsif tk.is_a? TkIDENTIFIER
+        $stderr.puts("#{tk}: #{tk.name}")
+      else
+        $stderr.puts(tk)
+      end
+    end
+    tk
+  end
+
+  def read_escape
+    case ch = getc
+    when "\n", "\r", "\f"
+    when "\\", "n", "t", "r", "f", "v", "a", "e", "b" #"
+      return "\\".concat(ch)
+    when /[0-7]/
+      ungetc ch
+      3.times do
+        case ch = getc
+        when /[0-7]/
+        when nil
+          break
+        else
+          ungetc
+          break
+        end
+      end
+      
+    when "x"
+      2.times do
+        case ch = getc
+        when /[0-9a-fA-F]/
+        when nil
+          break
+        else
+          ungetc
+          break
+        end
+      end
+      
+    when "M"
+      if (ch = getc) != '-'
+        ungetc
+      else
+        if (ch = getc) == "\\" #"
+          read_escape
+        end
+      end
+      
+    when "C", "c", "^"
+      if ch == "C" and (ch = getc) != "-"
+        ungetc
+      elsif (ch = getc) == "\\" #"
+        read_escape
+      end
+    when '#'
+      return ch
+    else
+      # other characters
+    end
+  end
+
+  def identify_string(ltype, quoted = ltype)
+    @ltype = ltype
+    @quoted = quoted
+    subtype = nil
+    str = ''
+    begin
+      while ch = getc
+        if @quoted == ch
+	  break
+        elsif @ltype != "'" && @ltype != "]" and ch == "#"
+          subtype = true
+        elsif ch == '\\' #'
+          e = read_escape
+          str.concat e unless e.nil?
+        else
+          str.concat ch
+        end
+      end
+      if @ltype == "/"
+	if peek(0) =~ /i|o|n|e|s/
+	  getc
+	end
+      end
+      if subtype
+        tk = Token(DLtype2Token[ltype], str)
+      else
+        tk = Token(Ltype2Token[ltype], str)
+      end
+    ensure
+      @ltype = nil
+      @quoted = nil
+      @lex_state = EXPR_END
+    end
+  end
+end
+
+######################################################################
+# GetText::RubyParser
+
+module GetText
+  module RubyParser
+    ID = ['gettext', '_', 'N_', 'sgettext', 's_']
+    PLURAL_ID = ['ngettext', 'n_']
+
+    module_function
+    def parse(file, targets = [])
+      lines = IO.readlines(file)
+      parse_lines(file, lines, targets)
+    end
+
+    def parse_lines(file_name, lines, targets)
+      file = StringIO.new(lines.join + "\n")
+      rl = RubyLexX.new
+      rl.set_input(file)
+      rl.skip_space = true
+      rl.readed_auto_clean_up = true
+
+      target = nil
+      msgid = nil
+      line_no = nil
+      while tk = rl.token
+        case tk
+        when RubyToken::TkIDENTIFIER, RubyToken::TkCONSTANT
+          if ID.include?(tk.name)
+            target = :normal
+          elsif PLURAL_ID.include?(tk.name)
+            target = :plural
+          else
+            target = nil
+          end
+          line_no = tk.line_no.to_s
+        when RubyToken::TkSTRING
+          if target
+            if msgid
+              msgid += tk.value
+            else
+              msgid = tk.value 
+            end
+          end
+        when RubyToken::TkPLUS, RubyToken::TkNL
+          #do nothing
+        when RubyToken::TkCOMMA
+          if msgid and target == :plural
+            msgid += "\000"
+            target = :normal
+          end
+        else
+          if msgid
+            key_existed = targets.assoc(msgid)
+            if key_existed 
+              targets[targets.index(key_existed)] = key_existed <<
+                file_name + ":" + line_no
+            else
+              targets << [msgid.gsub(/\n/, '\n'), file_name + ":" + line_no]
+            end
+            msgid = nil
+            target = nil
+          end
+        end
+        targets
+      end
+      targets
+    end
+
+    def target?(file)
+      true # always true, as default parser.
+    end
+    
+  end 
+end  
+
+if __FILE__ == $0
+  # ex) ruby c.rb foo.rb bar.rb
+  ARGV.each do |file|
+    p GetText::RubyParser.parse(file)
+  end
+end