i

[chise/ruby.git] / chise / character.rb

# Copyright (C) 2002-2004 Kouichirou Eto, All rights reserved.

require "singleton"
require "chise/parser"

module CHISE
  class CharacterFactory # generate Character object and cache them
    include Singleton

    MAX_CACHE_CHARACTER = 10000

    def initialize
      clear
      @parser = CharacterParser.new
    end

    def clear
      @chars = {}
    end

    def get(char_id)
      check_max
      mcs = @parser.parse(char_id)
      @chars[mcs] = Character.new(mcs) if @chars[mcs].nil?
      @chars[mcs]
    end

    def check_max
      clear if MAX_CACHE_CHARACTER < @chars.length # clear all caches.
    end
  end

  class Character
    def initialize(char_id=nil)
      @char_id = char_id
      @attributes = {}
      @check_all_database = false
    end
    attr_reader :char_id






    def to_i() @char_id end
    def mcs_utf8() Character.u4itou8(@char_id) end
    def mcs_hex() sprintf("%x", @char_id) end

    def self.get(char_id) # flyweight pattern
      CharacterFactory.instance.get(char_id)
    end

    def normalize_attribute_name(b)
      a = b.dup
      a.gsub!(/_/, "-") #underline\82Í-\82É\92u\8a·
      a.sub!(/-at-/,  "@")
      a.sub!(/^map-/,  "=>")
      a.sub!(/^to-/,   "->")
      a.sub!(/^from-/, "<-")
      a
    end

    def get_char_attribute(b) # XEmacs CHISE compatible API
      a = normalize_attribute_name(b)
      #p [a, b]
      atr = @attributes[a]
      return atr if atr
      atr = check_database(a)
      if atr
        @attributes[a] = atr
        return atr
      end
      return get_char_attribute("="+a) unless a =~ /^=/
      #\93ª\82É=\82ª\82Â\82¢\82Ä\82È\82¢\8fê\8d\87\82Í\82»\82ê\82ª\8fÈ\97ª\82³\82ê\82Ä\82¢\82é\82±\82Æ\82ð\89¼\92è\82µ\82Ä\81A\8dÄ\8bA\82·\82é
      nil
    end

    def put_char_attribute(b,v)
      a = normalize_attribute_name(b)
      @attributes[a] = v;
      CharDB.instance.put(a, mcs_utf8(), v)
    end

    def char_attribute_alist() check_all_database(); @attributes; end
    def char_attribute_list()  check_all_database(); @attributes.keys; end
    alias [] get_char_attribute  #\82»\82Ì\97ª\8fÌ
    alias []= put_char_attribute
    alias alist char_attribute_alist
    alias list  char_attribute_list

    def method_missing(mid, *args) # ref. ostruct.rb
      mname = mid.id2name
      return get_char_attribute(mname) if args.length == 0
      put_char_attribute(mname.chop, args[0]) if mname =~ /=$/ #\91ã\93ü
    end

    def has_attribute?() # \88Ó\96¡\82Ì\82 \82éattribute\82ð\8e\9d\82Á\82Ä\82Ü\82·\82©?
      keys = list
      keys.delete_if {|k|
        k =~ /ids/
      }
      return (keys.length != 0)
    end

    def ==(ch)
      return false if ch.nil?
      return false unless ch.is_a? Character
      self.char_id == ch.char_id
    end

    def self.u4itou4(num)
      return "" unless num.is_a?(Integer)
      return sprintf("%c%c%c%c", num&0xff, (num >> 8)&0xff, (num >> 16)&0xff, (num >> 24)&0xff) #UCS-4\90\94\92l\82ð\95¶\8e\9a\97ñ\82É\82µ\82Äreturn
    end

    def self.u4itou8(char_id) #ucs\82Ì\90\94\92l\82ð\8eó\82¯\82Æ\82è\81AUTF-8\82Ì\95¶\8e\9a\88ê\95¶\8e\9a\82ð\95Ô\82·
      begin
        u4 = Character.u4itou4(char_id)
        u8 = Uconv.u4tou8(u4)
        return u8
      rescue
        #raise ArgumentError, "invalid char_id (#{char_id})", caller(1)
        #print "error\n"
        return ""
      end
    end

    def check_database(a)
      db = CharDB.instance
      u8 = mcs_utf8()
      v = db.get(a, u8) # u8\82Å\95\\82³\82ê\82é\95¶\8e\9a\82Ìa\83A\83g\83\8a\83r\83\85\81[\83g\82ð\92²\82×\82é\81B
      v
    end

    def check_all_database() # \8c»\8dÝ\82Ì@char_id\82©\82ç\81A\95¶\8e\9a\83f\81[\83^\83x\81[\83X\82ð\8eQ\8fÆ\82·\82é
      return if @check_all_database
      return if @char_id.nil?
      db = CharDB.instance
      u8 = mcs_utf8()
      atrs = db.get_all(u8) #u8\82Å\95\\82³\82ê\82é\95¶\8e\9a\82Ì\83A\83g\83\8a\83r\83\85\81[\83g\82ð\91S\95\94\8e\9d\82Á\82Ä\82±\82¢
      atrs.each {|a,v|
        @attributes[a] = v #\82Æ\82©\82¢\82¤\8a´\82¶\82Å\91ã\93ü\82·\82é\82Ì\82Å\82¦\82¦\82©\82È?
      }
      @check_all_database = true #\8fd\82¢\8f\88\97\9d\82È\82Ì\82Å\88ê\89\9echeck\82·\82é
    end

    def ucs()
      #p "ucs"
      #ar = %w{ucs ucs-big5 ucs-cdp ucs-cns ucs-jis ucs-ks =>ucs =>ucs* =>ucs-jis}
      #ar = %w{ucs ucs-jis ucs-big5 ucs-cdp ucs-cns ucs-ks =>ucs =>ucs* =>ucs-jis}
      ar = %w{ucs-jis ucs =>ucs-jis}
      #\95À\82Ñ\8f\87\82Í\9c\93\88Ó\93I\82Å\81Aucs-jis\82ð\90æ\82É\8fo\82µ\82Ä\82¢\82é\81B\96{\97\88\82Í\82±\82ê\82à\8ew\92è\82Å\82«\82é\82æ\82¤\82É\82·\82é\82×\82«\81B
      ar.each {|a|      #p [a]
        u = get_char_attribute(a)
        return u if u
      }
      nil
    end

    #-------------------------------------------------------------------CCS\8aÖ\8cW
    def to_utf8() Uconv.u4tou8(Character.u4itou4(ucs())) end #UTF8\95¶\8e\9a\97ñ\82ð\95Ô\82·
    #alias to_s to_utf8
    alias to_s mcs_utf8

    def map_utf8()
      u = ucs()
      if u.nil? || 0xffff < u
        return to_er()
      else
        return to_utf8()
      end
    end
    alias map_ucs map_utf8

    def map_ucs_er()
      u = ucs()
      if u.nil? || 0xffff < u
        return to_er()
      else
        return Character.get(u).to_er()
      end
    end

    def to_euc()
      u = ucs()
      return "" if u.nil? || 0xffff < u
      Uconv.u16toeuc(Uconv.u4tou16(Character.u4itou4(ucs())))
    end

    def map_euc()
      e = to_euc()
      return e if e != ""
      return to_er()
    end

    def to_sjis()
      u = ucs()
      return "" if u.nil? || 0xffff < u
      Uconv.u16tosjis(Uconv.u4tou16(Character.u4itou4(ucs())))
    end

    def map_sjis()
      e = to_sjis()
      return e if e != ""
      return to_er()
    end

    def to_er(codesys=nil) #\8eÀ\91Ì\8eQ\8fÆ\82ð\95Ô\82·\81A\8aó\96]\82·\82écodesys\82ª\88ø\90\94(\96¢\8eÀ\91\95)
      return "" if @char_id.nil?
      return sprintf("&#x%04x;", @char_id) if @char_id <= 0xffff
      return sprintf("&#x%05x;", @char_id) if @char_id <= 0xfffff
      EntityReference.each_codesys {|codesys, er_prefix, keta, numtype|
        code = self[codesys]
        next if code.nil?
        return sprintf("&#{er_prefix}%0#{keta}#{numtype};", code)
      }
      return sprintf("&MCS-%08X;", @char_id) #\96{\93\96\82Í\82±\82ê\82Í\96³\82µ\82É\82µ\82½\82¢
    end

    def to_er_list()
      ar = []
      EntityReference.each_codesys {|codesys, er_prefix, keta, numtype|
        er = to_er(codesys)
        ar << er if er
      }
      ar
    end

    def inspect_x()
      return "<>" if @char_id.nil?
      ar = [to_utf8(), to_er().sub(/^&/,"").chop]
      "<"+ar.join(",")+">"
    end
    alias inspect inspect_x

    def inspect_all_codesys() #\96¢\8a®\90¬
      #to_er\82ð\91S\82Ä\82Ìcodesys\82É\82¨\82¢\82Ä\8eÀ\8ds\82·\82é\81B\82»\82Ì\8c\8b\89Ê\82ð\83R\83\93\83p\83N\83g\82É\82Ü\82Æ\82ß\82é
    end

    def inspect_all()
      ar = [inspect.chop]
      alist.to_a.sort.each {|a, v| ar << "#{a}:#{v}" }
      return ar.join(",")+">"
    end

    def dump_all()
      ar = [inspect]
      alist.to_a.sort.each {|a, v| ar << "#{a}:#{v}" }
      return ar.join('\n')+'\n'
    end

    def get_attributes()
      str = ""
      alist.to_a.sort.each {|a, v|
        str += "#{a}: #{v}\n"
      }
      str
    end

    def inspect_ids(hex_flag=false)
      ids = decompose
      ar = []
      ar << (hex_flag ? "x"+mcs_hex : to_utf8)
      if to_s != ids #ids\82ª\95\94\95i\82»\82Ì\82à\82Ì\82¾\82Á\82½\82ç\95\94\95i\92Ç\89Á\82Í\82µ\82È\82¢
        ids.each_char {|ch|
          char = ch.char
          next if char.is_ids?
          if hex_flag then
            ar << "x"+char.mcs_hex
          else
            u = char.to_utf8
            if u != ""
              ar << u
            else
              ar << char.to_er
            end
          end
        }
      end
      return "("+ar.join("\t")+")"
    end

    #--------------------------------------------------------------------IDS\8aÖ\8cW
    def glyph_decompose() do_decompose(false) end
    def decompose()       do_decompose(true)  end
    def do_decompose(check_meaning = true)
      k = self.to_s
      #       idss = self["ids"]
      #       return idss if idss
      #       return k if self.is_basic_kanji? #\8aî\96{\8a¿\8e\9a\82Ístop kanji\82Æ\82·\82é\82¼\82Æ\81B
      if check_meaning
        return self["ids-represent"] if self["ids-represent"] #ids_represent\82ð\8e\9d\82Á\82Ä\82¢\82é\8fê\8d\87\82Í\82»\82Ì\92l\82Æ\82·\82é\81B
        return self["ids-element"] if self["ids-element"] #ids_element\82ð\8e\9d\82Á\82Ä\82¢\82é\8fê\8d\87\82Í\82»\82Ì\92l\82Æ\82·\82é\81B
        idss = self["ids-meaning"]
        return idss if idss && 0 < idss.length && k != idss
      end
      idss = self["ids-aggregated"]
      return idss if idss && 0 < idss.length && k != idss
      idss = self["ids"]
      return idss if idss && 0 < idss.length && k != idss
      return k
      #       return k if idss.nil? || idss.length == 0 || k == idss
      #       if idss.char_length == 2
      # p ["What???", k, idss, k.inspect_all]
      #  #return idssx[1] #\93ñ\8cÂ\96Ú\82¾\82¯\95Ô\82·\82Æ\82©?
      #  return k #IDS\82É\93W\8aJ\82·\82é\95û\96@\82ª\96³\82¢\82Æ\81B
      #       end
      #       return k if k == idss
      #       if idss.include?(k) #<C5-4C4D><C6-4A37>\82±\82Ì\93ñ\95¶\8e\9a\82ÌBUG\91Î\8dô
      #  #return idss.sub(k, "")
      #  return k #IDS\82É\93W\8aJ\82·\82é\95û\96@\82ª\96³\82¢\82Æ\81B
      #       end
      #       return idss
    end

    def decompose_all
      pde = ""
      de = self.decompose #\8fo\94­\93_
      level = 0
      while true
        pde = de
        de = pde.decompose #\82à\82¤\88ê\93x\95ª\89ð\82ð\82µ\82Ä\82Ý\82é\81B
        break if pde == de #\83\8b\81[\83v\82ð\94²\82¯\82¾\82·
        exit if 10 < level #p ["too many recursive", self] 
        level += 1
      end
      return de
    end

    def decompose_all_nu(level=nil)
      level = 0 if level.nil?
      if 10 < level
        p ["too many recursive", self] 
        exit
      end
      de = self.decompose
      return de.decompose_all(level+1) if de != self #\82È\82É\82©\95Ï\89»\82ª\82 \82Á\82½\82©\82ç\8dÄ\8bA
      return de #\82à\82¤\82±\82ê\88È\8fã\95Ï\89»\82Í\96³\82³\82»\82¤\82¾\82¼\82Æ\81B
    end

    def is_ids?() 0x2ff0 <= @char_id && @char_id <= 0x2fff end

    def ids_operator_argc()
      return 0 unless is_ids?
      return 3 if @char_id == 0x2ff2 || @char_id == 0x2ff3
      return 2
    end
  end
end