Welcome to the "trac"-ing site of soap4r!
[soap4r] [httpclient] [openpgp4u] [pkcs1] [logger] [csv] [vtr]

Changeset 1683

Show
Ignore:
Timestamp:
07/22/06 16:10:00 (2 years ago)
Author:
nahi
Message:
  • define singleton method with instance_eval instead of define_method + proc. define_method with proc exhausts much memory by definition.
  • reduce $KCODE dependency. just use default value of XSD::Charset.encoding.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/lib/soap/baseData.rb

    r1652 r1683  
    11# soap/baseData.rb: SOAP4R - Base type library 
    2 # Copyright (C) 2000, 2001, 2003-2005  NAKAMURA, Hiroshi <nahi@ruby-lang.org>. 
     2# Copyright (C) 2000, 2001, 2003-2006  NAKAMURA, Hiroshi <nahi@ruby-lang.org>. 
    33 
    44# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can 
    …… 
    703703  end 
    704704 
    705   if RUBY_VERSION > "1.7.0" 
    706     def add_accessor(name) 
    707       methodname = name 
    708       if self.respond_to?(methodname) 
    709         methodname = safe_accessor_name(methodname) 
    710       end 
    711       Mapping.define_singleton_method(self, methodname) do 
    712         @data[@array.index(name)] 
    713       end 
    714       Mapping.define_singleton_method(self, methodname + '=') do |value| 
    715         @data[@array.index(name)] = value 
    716       end 
    717     end 
    718   else 
    719     def add_accessor(name) 
    720       methodname = safe_accessor_name(name) 
     705  # Mapping.define_singleton_method calls define_method with proc and it 
     706  # exhausts much memory for each singleton Object.  just instance_eval instead 
     707  # of it. 
     708  def add_accessor(name) 
     709    # untaint depends GenSupport.safemethodname 
     710    methodname = XSD::CodeGen::GenSupport.safemethodname(name).untaint 
     711    # untaint depends String#dump and Array#index 
     712    namedump = name.dump.untaint 
     713    unless self.respond_to?(methodname) 
    721714      instance_eval <<-EOS 
    722715        def #{methodname} 
    723           @data[@array.index(#{name.dump})] 
    724         end 
    725  
    726         def #{methodname}=(value) 
    727           @data[@array.index(#{name.dump})] = value 
     716          @data[@array.index(#{namedump})] 
    728717        end 
    729718      EOS 
    730719    end 
    731   end 
    732  
    733   def safe_accessor_name(name) 
    734     "var_" << name.gsub(/[^a-zA-Z0-9_]/, '') 
     720    unless self.respond_to?(methodname + "=") 
     721      instance_eval <<-EOS 
     722        def #{methodname}=(value) 
     723          @data[@array.index(#{namedump})] = value 
     724        end 
     725      EOS 
     726    end 
    735727  end 
    736728end 

  • trunk/lib/soap/mapping/mapping.rb

    r1677 r1683  
    4343    protect_threadvars(:SOAPMarshalDataKey, :SOAPExternalCES, :SOAPMarshalNoReference) do 
    4444      Thread.current[:SOAPMarshalDataKey] = {} 
    45       Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE 
     45      Thread.current[:SOAPExternalCES] = 
     46        opt[:external_ces] || XSD::Charset.encoding 
    4647      Thread.current[:SOAPMarshalNoReference] = opt[:no_reference] 
    4748      soap_obj = _obj2soap(obj, registry, type) 
    …… 
    5556    protect_threadvars(:SOAPMarshalDataKey, :SOAPExternalCES, :SOAPMarshalNoReference) do 
    5657      Thread.current[:SOAPMarshalDataKey] = {} 
    57       Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE 
     58      Thread.current[:SOAPExternalCES] = 
     59        opt[:external_ces] || XSD::Charset.encoding 
    5860      Thread.current[:SOAPMarshalNoReference] = opt[:no_reference] 
    5961      obj = _soap2obj(node, registry, klass) 
    …… 
    6870    protect_threadvars(:SOAPMarshalDataKey, :SOAPExternalCES, :SOAPMarshalNoReference) do 
    6971      Thread.current[:SOAPMarshalDataKey] = {} 
    70       Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE 
     72      Thread.current[:SOAPExternalCES] = 
     73        opt[:external_ces] || XSD::Charset.encoding 
    7174      Thread.current[:SOAPMarshalNoReference] = opt[:no_reference] 
    7275      ary.each do |ele| 
    …… 
    8386    protect_threadvars(:SOAPMarshalDataKey, :SOAPExternalCES, :SOAPMarshalNoReference) do 
    8487      Thread.current[:SOAPMarshalDataKey] = {} 
    85       Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE 
     88      Thread.current[:SOAPExternalCES] = 
     89        opt[:external_ces] || XSD::Charset.encoding 
    8690      Thread.current[:SOAPMarshalNoReference] = opt[:no_reference] 
    8791      add_md_ary(md_ary, ary, [], registry) 
    …… 
    313317    else 
    314318      values.each do |attr_name, value| 
    315         name = XSD::CodeGen::GenSupport.safevarname(attr_name) 
     319        # untaint depends GenSupport.safevarname 
     320        name = XSD::CodeGen::GenSupport.safevarname(attr_name).untaint 
    316321        setter = name + "=" 
    317322        if obj.respond_to?(setter) 
    …… 
    320325          obj.instance_variable_set('@' + name, value) 
    321326          begin 
    322             define_attr_accessor(obj, name, 
    323               proc { instance_variable_get('@' + name) }, 
    324               proc { |value| instance_variable_set('@' + name, value) }) 
     327            unless obj.respond_to?(name) 
     328              obj.instance_eval <<-EOS 
     329                def #{name} 
     330                  @#{name} 
     331                end 
     332              EOS 
     333            end 
     334            unless self.respond_to?(name + "=") 
     335              obj.instance_eval <<-EOS 
     336                def #{name}=(value) 
     337                  @#{name} = value 
     338                end 
     339              EOS 
     340            end 
    325341          rescue TypeError 
    326342            # singleton class may not exist (e.g. Float) 
    …… 
    329345      end 
    330346    end 
    331   end 
    332  
    333   def self.define_attr_accessor(obj, name, getterproc, setterproc = nil) 
    334     define_singleton_method(obj, name, &getterproc) if getterproc 
    335     define_singleton_method(obj, name + '=', &setterproc) if setterproc 
    336347  end 
    337348 

  • trunk/lib/soap/mapping/registry.rb

    r1677 r1683  
    134134private 
    135135 
    136   if RUBY_VERSION > "1.7.0" 
    137     def __define_attr_accessor(qname) 
    138       name = XSD::CodeGen::GenSupport.safemethodname(qname.name) 
    139       getter = setter = nil 
    140       unless self.respond_to?(name) 
    141         getter = proc { self[qname] } 
    142       end 
    143       unless self.respond_to?(name + "=") 
    144         setter = proc { |value| self[qname] = value } 
    145       end 
    146       Mapping.define_attr_accessor(self, name, getter, setter) 
    147     end 
    148   else 
    149     def __define_attr_accessor(qname) 
    150       name = XSD::CodeGen::GenSupport.safemethodname(qname.name) 
    151       unless self.respond_to?(name) 
    152         instance_eval <<-EOS 
    153           def #{name} 
    154             self[#{qname.dump}] 
    155           end 
    156         EOS 
    157       end 
    158       unless self.respond_to?(name + "=") 
    159         instance_eval <<-EOS 
    160           def #{name}=(value) 
    161             self[#{qname.dump}] = value 
    162           end 
    163         EOS 
    164       end 
     136  # Mapping.define_attr_accessor calls define_method with proc and it exhausts 
     137  # much memory for each singleton Object.  just instance_eval instead of it. 
     138  def __define_attr_accessor(qname) 
     139    # untaint depends GenSupport.safemethodname 
     140    name = XSD::CodeGen::GenSupport.safemethodname(qname.name).untaint 
     141    # untaint depends QName#dump 
     142    qnamedump = qname.dump.untaint 
     143    unless self.respond_to?(name) 
     144      instance_eval <<-EOS 
     145        def #{name} 
     146          self[#{qnamedump}] 
     147        end 
     148      EOS 
     149    end 
     150    unless self.respond_to?(name + "=") 
     151      instance_eval <<-EOS 
     152        def #{name}=(value) 
     153          self[#{qnamedump}] = value 
     154        end 
     155      EOS 
    165156    end 
    166157  end 

  • trunk/lib/soap/mapping/wsdlliteralregistry.rb

    r1674 r1683  
    491491  end 
    492492 
    493   if RUBY_VERSION > "1.7.0" 
    494     def define_xmlattr_accessor(obj, qname) 
    495       name = XSD::CodeGen::GenSupport.safemethodname('xmlattr_' + qname.name) 
    496       Mapping.define_attr_accessor(obj, name, 
    497         proc { @__xmlattr[qname] }, 
    498         proc { |value| @__xmlattr[qname] = value }) 
    499     end 
    500   else 
    501     def define_xmlattr_accessor(obj, qname) 
    502       name = XSD::CodeGen::GenSupport.safemethodname('xmlattr_' + qname.name) 
     493  # Mapping.define_attr_accessor calls define_method with proc and it exhausts 
     494  # much memory for each singleton Object.  just instance_eval instead of it. 
     495  def define_xmlattr_accessor(obj, qname) 
     496    # untaint depends GenSupport.safemethodname 
     497    name = XSD::CodeGen::GenSupport.safemethodname('xmlattr_' + qname.name).untaint 
     498    # untaint depends QName#dump 
     499    qnamedump = qname.dump.untaint 
     500    obj.instance_eval <<-EOS 
     501      def #{name} 
     502        @__xmlattr[#{qnamedump}] 
     503      end 
     504 
     505      def #{name}=(value) 
     506        @__xmlattr[#{qnamedump}] = value 
     507      end 
     508    EOS 
     509  end 
     510 
     511  # Mapping.define_attr_accessor calls define_method with proc and it exhausts 
     512  # much memory for each singleton Object.  just instance_eval instead of it. 
     513  def define_xmlattr(obj) 
     514    obj.instance_variable_set('@__xmlattr', {}) 
     515    unless obj.respond_to?(:__xmlattr) 
    503516      obj.instance_eval <<-EOS 
    504         def #{name} 
    505           @__xmlattr[#{qname.dump}] 
    506         end 
    507  
    508         def #{name}=(value) 
    509           @__xmlattr[#{qname.dump}] = value 
     517        def __xmlattr 
     518          @__xmlattr 
    510519        end 
    511520      EOS 
    512     end 
    513   end 
    514  
    515   if RUBY_VERSION > "1.7.0" 
    516     def define_xmlattr(obj) 
    517       obj.instance_variable_set('@__xmlattr', {}) 
    518       unless obj.respond_to?(:__xmlattr) 
    519         Mapping.define_attr_accessor(obj, :__xmlattr, proc { @__xmlattr }) 
    520       end 
    521     end 
    522   else 
    523     def define_xmlattr(obj) 
    524       obj.instance_variable_set('@__xmlattr', {}) 
    525       unless obj.respond_to?(:__xmlattr) 
    526         obj.instance_eval <<-EOS 
    527           def __xmlattr 
    528             @__xmlattr 
    529           end 
    530         EOS 
    531       end 
    532521    end 
    533522  end 

  • trunk/lib/soap/rpc/driver.rb

    r1607 r1683  
    223223  end 
    224224 
    225   if RUBY_VERSION > "1.7.0" 
    226     def add_method_interface(name, param_count) 
    227       ::SOAP::Mapping.define_singleton_method(self, name) do |*arg| 
    228         unless arg.size == param_count 
     225  # Mapping.define_singleton_method calls define_method with proc and it 
     226  # exhausts much memory for each singleton Object.  just instance_eval instead 
     227  # of it. 
     228  def add_method_interface(name, param_count) 
     229    instance_eval <<-EOS 
     230      def #{name}(*arg) 
     231        unless arg.size == #{param_count} 
    229232          raise ArgumentError.new( 
    230           "wrong number of arguments (#{arg.size} for #{param_count})") 
     233            "wrong number of arguments (\#{arg.size} for #{param_count})") 
    231234        end 
    232         call(name, *arg) 
     235        call(#{name.dump}, *arg) 
    233236      end 
    234       self.method(name) 
    235     end 
    236   else 
    237     def add_method_interface(name, param_count) 
    238       instance_eval <<-EOS 
    239         def #{name}(*arg) 
    240           unless arg.size == #{param_count} 
    241             raise ArgumentError.new( 
    242               "wrong number of arguments (\#{arg.size} for #{param_count})") 
    243           end 
    244           call(#{name.dump}, *arg) 
    245         end 
    246       EOS 
    247       self.method(name) 
    248     end 
     237    EOS 
     238    self.method(name) 
    249239  end 
    250240end 

  • trunk/lib/xsd/charset.rb

    r1656 r1683  
    168168  end 
    169169 
    170   def Charset.is_ces(str, code = $KCODE) 
     170  def Charset.is_ces(str, code = @internal_encoding) 
    171171    case code 
    172172    when 'NONE'